mirrors/actix-web
1
0
Fork 0
mirror of https://github.com/actix/actix-web.git synced 2024-11-26 19:41:12 +00:00
Code Issues Projects Releases Wiki Activity

added ServerSettings

Browse source
This commit is contained in:
Nikolay Kim 2017-12-07 22:54:44 -08:00
parent b71ddf7b4c
commit 2192d14eff
6 changed files with 138 additions and 78 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

20
examples/basic.rs
View file

@ -72,15 +72,6 @@ fn main() {
.resource("/user/{name}/", |r| r.method(Method::GET).f(with_param))
// async handler
.resource("/async/{name}", |r| r.method(Method::GET).a(index_async))
// redirect
.resource("/", |r| r.method(Method::GET).f(|req| {
println!("{:?}", req);
httpcodes::HTTPFound
.build()
.header("LOCATION", "/index.html")
.body(Body::Empty)
}))
.resource("/test", |r| r.f(|req| {
match *req.method() {
Method::GET => httpcodes::HTTPOk,
@ -89,7 +80,16 @@ fn main() {
}
}))
// static files
.resource("/static", |r| r.h(fs::StaticFiles::new("examples/static/", true))))
.resource("/static", |r| r.h(fs::StaticFiles::new("examples/static/", true)))
// redirect
.resource("/", |r| r.method(Method::GET).f(|req| {
println!("{:?}", req);
httpcodes::HTTPFound
.build()
.header("LOCATION", "/index.html")
.body(Body::Empty)
})))
.serve::<_, ()>("127.0.0.1:8080").unwrap();
println!("Started http server: 127.0.0.1:8080");

20
src/channel.rs
View file

@ -1,4 +1,3 @@
use std::rc::Rc;
use std::net::SocketAddr;
use actix::dev::*;
@ -10,6 +9,7 @@ use h1;
use h2;
use pipeline::Pipeline;
use httprequest::HttpRequest;
use server::ServerSettings;
/// Low level http request handler
pub trait HttpHandler: 'static {
@ -51,21 +51,17 @@ pub struct HttpChannel<T, H>
impl<T, H> HttpChannel<T, H>
where T: AsyncRead + AsyncWrite + 'static, H: HttpHandler + 'static
{
pub fn new(stream: T,
local: SocketAddr,
secure: bool,
peer: Option<SocketAddr>,
router: Rc<Vec<H>>,
http2: bool) -> HttpChannel<T, H>
pub fn new(settings: ServerSettings<H>,
stream: T, peer: Option<SocketAddr>, http2: bool) -> HttpChannel<T, H>
{
if http2 {
HttpChannel {
proto: Some(HttpProtocol::H2(
h2::Http2::new(stream, local, secure, peer, router, Bytes::new()))) }
h2::Http2::new(settings, stream, peer, Bytes::new()))) }
} else {
HttpChannel {
proto: Some(HttpProtocol::H1(
h1::Http1::new(stream, local, secure, peer, router))) }
h1::Http1::new(settings, stream, peer))) }
}
}
}
@ -110,9 +106,9 @@ impl<T, H> Future for HttpChannel<T, H>
let proto = self.proto.take().unwrap();
match proto {
HttpProtocol::H1(h1) => {
let (stream, local, secure, addr, router, buf) = h1.into_inner();
self.proto = Some(HttpProtocol::H2(
h2::Http2::new(stream, local, secure, addr, router, buf)));
let (settings, stream, addr, buf) = h1.into_inner();
self.proto = Some(
HttpProtocol::H2(h2::Http2::new(settings, stream, addr, buf)));
self.poll()
}
_ => unreachable!()

27
src/h1.rs
View file

@ -1,5 +1,4 @@
use std::{self, io, ptr};
use std::rc::Rc;
use std::net::SocketAddr;
use std::time::Duration;
use std::collections::VecDeque;
@ -21,6 +20,7 @@ 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;
@ -60,8 +60,7 @@ enum Item {
pub(crate) struct Http1<T: AsyncWrite + 'static, H: 'static> {
flags: Flags,
router: Rc<Vec<H>>,
local: SocketAddr,
settings: ServerSettings<H>,
addr: Option<SocketAddr>,
stream: H1Writer<T>,
reader: Reader,
@ -79,11 +78,14 @@ impl<T, H> Http1<T, H>
where T: AsyncRead + AsyncWrite + 'static,
H: HttpHandler + 'static
{
pub fn new(stream: T, local: SocketAddr, secure: bool,
addr: Option<SocketAddr>, router: Rc<Vec<H>>) -> Self {
Http1{ router: router,
local: local,
flags: if secure { Flags::SECURE | Flags::KEEPALIVE } else { Flags::KEEPALIVE },
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,
addr: addr,
stream: H1Writer::new(stream),
reader: Reader::new(),
@ -92,11 +94,8 @@ impl<T, H> Http1<T, H>
keepalive_timer: None }
}
pub fn into_inner(mut self) -> (T, SocketAddr, bool,
Option<SocketAddr>, Rc<Vec<H>>, Bytes) {
(self.stream.unwrap(), self.local,
self.flags.contains(Flags::SECURE),
self.addr, self.router, self.read_buf.freeze())
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 poll(&mut self) -> Poll<Http1Result, ()> {
@ -205,7 +204,7 @@ impl<T, H> Http1<T, H>
// start request processing
let mut pipe = None;
for h in self.router.iter() {
for h in self.settings.handlers() {
req = match h.handle(req) {
Ok(t) => {
pipe = Some(t);

20
src/h2.rs
View file

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

2
src/lib.rs
View file

@ -131,7 +131,7 @@ pub mod dev {
pub use pipeline::Pipeline;
pub use channel::{HttpChannel, HttpHandler, IntoHttpHandler};
pub use param::{FromParam, Params};
pub use server::ServerSettings;
pub use httprequest::UrlEncoded;
pub use httpresponse::HttpResponseBuilder;
}

127
src/server.rs
View file

@ -26,6 +26,53 @@ 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>,
addr: Option<SocketAddr>,
secure: bool,
sethost: bool,
}
impl<H> Clone for ServerSettings<H> {
fn clone(&self) -> Self {
ServerSettings(Rc::clone(&self.0))
}
}
impl<H> ServerSettings<H> {
/// 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 }))
}
/// 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
}
/// Returns true if connection is secure(https)
pub fn secure(&self) -> bool {
self.0.secure
}
/// Should http channel set *HOST* header
pub fn set_host_header(&self) -> bool {
self.0.sethost
}
}
/// An HTTP Server
///
/// `T` - async stream, anything that implements `AsyncRead` + `AsyncWrite`.
@ -34,9 +81,10 @@ use channel::{HttpChannel, HttpHandler, IntoHttpHandler};
///
/// `H` - request handler
pub struct HttpServer<T, A, H> {
h: Rc<Vec<H>>,
h: Option<Vec<H>>,
io: PhantomData<T>,
addr: PhantomData<A>,
sethost: bool,
}
impl<T: 'static, A: 'static, H: 'static> Actor for HttpServer<T, A, H> {
@ -51,9 +99,16 @@ 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: Rc::new(apps),
HttpServer {h: Some(apps),
io: PhantomData,
addr: PhantomData}
addr: PhantomData,
sethost: false}
}
/// Set *HOST* header if not set
pub fn set_host_header(mut self) -> Self {
self.sethost = true;
self
}
}
@ -63,15 +118,18 @@ impl<T, A, H> HttpServer<T, A, H>
H: HttpHandler,
{
/// Start listening for incomming connections from stream.
pub fn serve_incoming<S, Addr>(self, stream: S, secure: bool) -> io::Result<Addr>
pub fn serve_incoming<S, Addr>(mut self, stream: S, secure: bool) -> io::Result<Addr>
where Self: ActorAddress<Self, Addr>,
S: Stream<Item=(T, A), Error=io::Error> + 'static
{
let addr: SocketAddr = "127.0.0.1:8080".parse().unwrap();
let settings = ServerSettings::new(
self.h.take().unwrap(), Some(addr), secure, self.sethost);
Ok(HttpServer::create(move |ctx| {
let addr: SocketAddr = "127.0.0.1:8080".parse().unwrap();
ctx.add_stream(stream.map(
move |(t, _)| IoStream{io: t, srv: addr,
peer: None, http2: false, secure: secure}));
move |(t, _)| IoStream{settings: settings.clone(),
io: t, peer: None, http2: false}));
self
}))
}
@ -107,18 +165,21 @@ impl<H: HttpHandler> HttpServer<TcpStream, net::SocketAddr, H> {
///
/// This methods converts address to list of `SocketAddr`
/// then binds to all available addresses.
pub fn serve<S, Addr>(self, addr: S) -> io::Result<Addr>
pub fn serve<S, Addr>(mut self, addr: S) -> io::Result<Addr>
where Self: ActorAddress<Self, Addr>,
S: net::ToSocketAddrs,
{
let addrs = self.bind(addr)?;
let settings = ServerSettings::new(
self.h.take().unwrap(), Some(addrs[0].0), false, self.sethost);
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{io: t, srv: addr,
peer: Some(a), http2: false, secure: false}));
move |(t, a)| IoStream{settings: s.clone(),
io: t, peer: Some(a), http2: false}));
}
self
}))
@ -132,11 +193,14 @@ impl<H: HttpHandler> HttpServer<TlsStream<TcpStream>, net::SocketAddr, H> {
///
/// This methods converts address to list of `SocketAddr`
/// then binds to all available addresses.
pub fn serve_tls<S, Addr>(self, addr: S, pkcs12: ::Pkcs12) -> io::Result<Addr>
pub fn serve_tls<S, Addr>(mut self, addr: S, pkcs12: ::Pkcs12) -> io::Result<Addr>
where Self: ActorAddress<Self, Addr>,
S: net::ToSocketAddrs,
{
let addrs = self.bind(addr)?;
let settings = ServerSettings::new(
self.h.take().unwrap(), Some(addrs[0].0.clone()), true, self.sethost);
let acceptor = match TlsAcceptor::builder(pkcs12) {
Ok(builder) => {
match builder.build() {
@ -151,12 +215,14 @@ impl<H: HttpHandler> HttpServer<TlsStream<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();
TlsAcceptorExt::accept_async(acc.as_ref(), stream)
.map(move |t|
IoStream{io: t, srv: srv.clone(),
peer: Some(addr), http2: false, secure: true})
IoStream{settings: st2.clone(),
io: t, peer: Some(addr), http2: false})
.map_err(|err| {
trace!("Error during handling tls connection: {}", err);
io::Error::new(io::ErrorKind::Other, err)
@ -175,15 +241,16 @@ impl<H: HttpHandler> HttpServer<SslStream<TcpStream>, net::SocketAddr, H> {
///
/// This methods converts address to list of `SocketAddr`
/// then binds to all available addresses.
pub fn serve_tls<S, Addr>(self, addr: S, identity: ParsedPkcs12) -> io::Result<Addr>
pub fn serve_tls<S, Addr>(mut self, addr: S, identity: ParsedPkcs12) -> io::Result<Addr>
where Self: ActorAddress<Self, Addr>,
S: net::ToSocketAddrs,
{
let addrs = self.bind(addr)?;
let acceptor = match SslAcceptorBuilder::mozilla_intermediate(SslMethod::tls(),
&identity.pkey,
&identity.cert,
&identity.chain)
let settings = ServerSettings::new(
self.h.take().unwrap(), Some(addrs[0].0.clone()), true, self.sethost);
let acceptor = match SslAcceptorBuilder::mozilla_intermediate(
SslMethod::tls(), &identity.pkey, &identity.cert, &identity.chain)
{
Ok(mut builder) => {
match builder.builder_mut().set_alpn_protocols(&[b"h2", b"http/1.1"]) {
@ -198,8 +265,10 @@ 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) =
@ -209,8 +278,8 @@ impl<H: HttpHandler> HttpServer<SslStream<TcpStream>, net::SocketAddr, H> {
} else {
false
};
IoStream{io: stream, srv: srv.clone(),
peer: Some(addr), http2: http2, secure: true}
IoStream{settings: st2.clone(),
io: stream, peer: Some(addr), http2: http2}
})
.map_err(|err| {
trace!("Error during handling tls connection: {}", err);
@ -223,27 +292,26 @@ impl<H: HttpHandler> HttpServer<SslStream<TcpStream>, net::SocketAddr, H> {
}
}
struct IoStream<T> {
struct IoStream<T, H> {
io: T,
srv: SocketAddr,
peer: Option<SocketAddr>,
http2: bool,
secure: bool,
settings: ServerSettings<H>,
}
impl<T> ResponseType for IoStream<T>
impl<T, H> ResponseType for IoStream<T, H>
where T: AsyncRead + AsyncWrite + 'static
{
type Item = ();
type Error = ();
}
impl<T, A, H> StreamHandler<IoStream<T>, io::Error> for HttpServer<T, A, H>
impl<T, A, H> StreamHandler<IoStream<T, H>, io::Error> for HttpServer<T, A, H>
where T: AsyncRead + AsyncWrite + 'static,
H: HttpHandler + 'static,
A: 'static {}
impl<T, A, H> Handler<IoStream<T>, io::Error> for HttpServer<T, A, H>
impl<T, A, H> Handler<IoStream<T, H>, io::Error> for HttpServer<T, A, H>
where T: AsyncRead + AsyncWrite + 'static,
H: HttpHandler + 'static,
A: 'static,
@ -252,12 +320,11 @@ impl<T, A, H> Handler<IoStream<T>, io::Error> for HttpServer<T, A, H>
debug!("Error handling request: {}", err)
}
fn handle(&mut self, msg: IoStream<T>, _: &mut Context<Self>)
-> Response<Self, IoStream<T>>
fn handle(&mut self, msg: IoStream<T, H>, _: &mut Context<Self>)
-> Response<Self, IoStream<T, H>>
{
Arbiter::handle().spawn(
HttpChannel::new(msg.io, msg.srv, msg.secure,
msg.peer, Rc::clone(&self.h), msg.http2));
HttpChannel::new(msg.settings, msg.io, msg.peer, msg.http2));
Self::empty()
}
}