added ServerSettings

examples/basic.rs

@@ -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");

src/channel.rs

@@ -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,
+    pub fn new(settings: ServerSettings<H>,
-               local: SocketAddr,
+               stream: T, peer: Option<SocketAddr>, http2: bool) -> HttpChannel<T, H>
-               secure: bool,
-               peer: Option<SocketAddr>,
-               router: Rc<Vec<H>>,
-               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();
+                let (settings, stream, addr, buf) = h1.into_inner();
-                self.proto = Some(HttpProtocol::H2(
+                self.proto = Some(
-                    h2::Http2::new(stream, local, secure, addr, router, buf)));
+                    HttpProtocol::H2(h2::Http2::new(settings, stream, addr, buf)));
                 self.poll()
             }
             _ => unreachable!()

src/h1.rs

@@ -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>>,
+    settings: ServerSettings<H>,
-    local: SocketAddr,
     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,
+    pub fn new(settings: ServerSettings<H>, stream: T, addr: Option<SocketAddr>) -> Self {
-               addr: Option<SocketAddr>, router: Rc<Vec<H>>) -> Self {
+        let flags = if settings.secure() {
-        Http1{ router: router,
+            Flags::SECURE | Flags::KEEPALIVE
-               local: local,
+        } else {
-               flags: if secure { Flags::SECURE | Flags::KEEPALIVE } else { Flags::KEEPALIVE },
+            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,
+    pub fn into_inner(mut self) -> (ServerSettings<H>, T, Option<SocketAddr>, Bytes) {
-                                    Option<SocketAddr>, Rc<Vec<H>>, Bytes) {
+        (self.settings, self.stream.unwrap(), self.addr, self.read_buf.freeze())
-        (self.stream.unwrap(), self.local,
-         self.flags.contains(Flags::SECURE),
-         self.addr, self.router, 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);

src/h2.rs

@@ -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>>,
+    settings: ServerSettings<H>,
-    local: SocketAddr,
     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,
+    pub fn new(settings: ServerSettings<H>, stream: T, addr: Option<SocketAddr>, buf: Bytes) -> Self
-               addr: Option<SocketAddr>, router: Rc<Vec<H>>, buf: Bytes) -> Self {
+    {
-        Http2{ flags: if secure { Flags::SECURE } else { Flags::empty() },
+        Http2{ flags: if settings.secure() { Flags::SECURE } else { Flags::empty() },
-               router: router,
+               settings: settings,
-               local: local,
                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);

src/lib.rs

@@ -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;
 }

src/server.rs

@@ -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,
+                move |(t, _)| IoStream{settings: settings.clone(),
-                                       peer: None, http2: false, secure: secure}));
+                                       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,
+                    move |(t, a)| IoStream{settings: s.clone(),
-                                           peer: Some(a), http2: false, secure: false}));
+                                           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(),
+                             IoStream{settings: st2.clone(),
-                                      peer: Some(addr), http2: false, secure: true})
+                                      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(),
+        let settings = ServerSettings::new(
-                                                                      &identity.pkey,
+            self.h.take().unwrap(), Some(addrs[0].0.clone()), true, self.sethost);
-                                                                      &identity.cert,
+
-                                                                      &identity.chain)
+        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(),
+                            IoStream{settings: st2.clone(),
-                                     peer: Some(addr), http2: http2, secure: true}
+                                     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>)
+    fn handle(&mut self, msg: IoStream<T, H>, _: &mut Context<Self>)
-              -> Response<Self, IoStream<T>>
+              -> Response<Self, IoStream<T, H>>
     {
         Arbiter::handle().spawn(
-            HttpChannel::new(msg.io, msg.srv, msg.secure,
+            HttpChannel::new(msg.settings, msg.io, msg.peer, msg.http2));
-                             msg.peer, Rc::clone(&self.h), msg.http2));
         Self::empty()
     }
 }