router work

Author: vinniefalco

example/server/asio_params.hpp

@@ -11,15 +11,10 @@
 #define BOOST_HTTP_IO_EXAMPLE_SERVER_ASIO_PARAMS_HPP
 
 #include <boost/http_io/detail/config.hpp>
-#include <boost/http_io/server/handler_params.hpp>
 
 namespace boost {
 namespace http_io {
 
-struct asio_params : handler_params
-{
-};
-
 } // http_io
 } // boost
 

example/server/handler.cpp

@@ -156,36 +156,34 @@ static
 void
 path_cat(
     std::string& result,
-    core::string_view base,
-    core::string_view path)
+    core::string_view prefix,
+    urls::segments_view suffix)
 {
-    if(base.empty())
-    {
-        result = path;
-        return;
-    }
-    result = base;
+    result = prefix;
 
 #ifdef BOOST_MSVC
     char constexpr path_separator = '\\';
-    if(result.back() == path_separator)
-        result.resize(result.size() - 1);
-    result.append(path.data(), path.size());
-    for(auto& c : result)
-        if(c == '/')
-            c = path_separator;
 #else
     char constexpr path_separator = '/';
-    if(result.back() == path_separator)
-        result.resize(result.size() - 1);
-    result.append(path.data(), path.size());
 #endif
+    if( result.back() == path_separator)
+        result.resize(result.size() - 1); // remove trailing
+#ifdef BOOST_MSVC
+    for(auto& c : result)
+        if( c == '/')
+            c = path_separator;
+#endif
+    for(auto const& seg : suffix)
+    {
+        result.push_back(path_separator);
+        result.append(seg);
+    }
 }
 
 //------------------------------------------------
 
 static
-void
+bool
 make_error_response(
     http_proto::status code,
     http_proto::request_base const& req,
@@ -244,10 +242,12 @@ make_error_response(
 
     sr.start(res, http_proto::string_body(
         std::move(body)));
+
+    return false;
 }
 
 static
-void
+bool
 service_unavailable(
     http_proto::response& res,
     http_proto::serializer& sr,
@@ -294,18 +294,20 @@ service_unavailable(
         res,
         http_proto::string_body(
             std::move(s)));
+    return false;
 }
 
 //------------------------------------------------
 
-void
+bool
 file_responder::
 operator()(
-    handler_params& params) const
+    Request& req,
+    Response& res) const
 {
-    if(params.is_shutting_down)
+    if(req.is_shutting_down)
         return service_unavailable(
-            params.res, params.serializer, params.req);
+            res.res, res.sr, req.req);
 
 #if 0
     // Returns a server error response
@@ -323,17 +325,15 @@ operator()(
 #endif
 
     // Request path must be absolute and not contain "..".
-    if( params.req.target().empty() ||
-        params.req.target()[0] != '/' ||
-        params.req.target().find("..") != core::string_view::npos)
+    if( req.req.target().empty() ||
+        req.req.target()[0] != '/' ||
+        req.req.target().find("..") != core::string_view::npos)
         return make_error_response(http_proto::status::bad_request,
-            params.req, params.res, params.serializer);
+            req.req, res.res, res.sr);
 
     // Build the path to the requested file
     std::string path; 
-    path_cat(path, doc_root_, params.req.target());
-    if(params.req.target().back() == '/')
-        path.append("index.html");
+    path_cat(path, doc_root_, req.path);
 
     // Attempt to open the file
     system::error_code ec;
@@ -344,52 +344,55 @@ operator()(
         size = f.size(ec);
     if(! ec.failed())
     {
-        params.res.set_start_line(
+        res.res.set_start_line(
             http_proto::status::ok,
-            params.req.version());
-        params.res.set(http_proto::field::server, "Boost");
-        params.res.set_keep_alive(params.req.keep_alive());
-        params.res.set_payload_size(size);
+            req.req.version());
+        res.res.set(http_proto::field::server, "Boost");
+        res.res.set_keep_alive(req.req.keep_alive());
+        res.res.set_payload_size(size);
 
         auto mt = mime_type(get_extension(path));
-        params.res.append(
+        res.res.append(
             http_proto::field::content_type, mt);
 
-        params.serializer.start<http_proto::file_source>(
-            params.res, std::move(f), size);
-        return;
+        res.sr.start<http_proto::file_source>(
+            res.res, std::move(f), size);
+        return false;
     }
 
     if(ec == system::errc::no_such_file_or_directory)
         return make_error_response(
             http_proto::status::not_found,
-                params.req, params.res, params.serializer);
+                req.req, res.res, res.sr);
 
     // ec.message()?
     return make_error_response(
         http_proto::status::internal_server_error,
-            params.req, params.res, params.serializer);
+            req.req, res.res, res.sr);
 }
 
 //------------------------------------------------
 
-void
+bool
 https_redirect_responder::
-operator()(handler_params& params) const
+operator()(
+    Request& req,
+    Response& res) const
 {
-    if(params.is_shutting_down)
+    if(req.is_shutting_down)
         return service_unavailable(
-            params.res, params.serializer, params.req);
+            res.res, res.sr, req.req);
 
     std::string body;
-    prepare_error(params.res, body,
-        http_proto::status::moved_permanently, params.req);
-    urls::url u1(params.req.target());
+    prepare_error(res.res, body,
+        http_proto::status::moved_permanently, req.req);
+    urls::url u1(req.req.target());
     u1.set_scheme_id(urls::scheme::https);
     u1.set_host_address("localhost"); // VFALCO WTF IS THIS!
-    params.res.append(http_proto::field::location, u1.buffer());
-    params.serializer.start(params.res,
+    res.res.append(http_proto::field::location, u1.buffer());
+    res.sr.start(res.res,
         http_proto::string_body( std::move(body)));
+    return false;
 }
 
 } // http_io

example/server/handler.hpp

@@ -11,7 +11,7 @@
 #define BOOST_HTTP_IO_EXAMPLE_SERVER_HANDLER_HPP
 
 #include <boost/http_io/detail/config.hpp>
-#include <boost/http_io/server/handler_params.hpp>
+#include <boost/http_io/server/route_params.hpp>
 #include <boost/http_io/server/router.hpp>
 #include <boost/http_proto/request_base.hpp>
 #include <boost/http_proto/response.hpp>
@@ -21,13 +21,13 @@
 namespace boost {
 namespace http_io {
 
-using router_type = router<handler_params>;
+using router_type = router<Response>;
 
 //------------------------------------------------
 
 struct https_redirect_responder
 {
-    void operator()(handler_params&) const;
+    bool operator()(Request&, Response&) const;
 };
 
 //------------------------------------------------
@@ -40,7 +40,7 @@ struct file_responder
     {
     }
 
-    void operator()(handler_params&) const;
+    bool operator()(Request&, Response&) const;
 
 private:
     std::string doc_root_;

example/server/http_responder.hpp

@@ -86,19 +86,23 @@ class http_responder
 
         BOOST_ASSERT(pr_.is_complete());
 
-        // find the route
-        auto found = rr_.invoke(
+        Request req{
             pr_.get().method(),
-            pr_.get().target(),
-            handler_params{
-                *pconfig_,
-                pr_.get(),
-                res_,
-                pr_,
-                sr_,
-                self().server().is_stopping()});
-        BOOST_ASSERT(found);
-        (void)found;
+            urls::segments_encoded_view(
+                pr_.get().target()),
+            *this->pconfig_,
+            pr_.get(),
+            pr_,
+            self().server().is_stopping()
+        };
+        Response res{
+            res_,
+            sr_
+        };
+
+        // invoke handlers for the route
+        auto cont = rr_(req, res);
+        BOOST_ASSERT(! cont);
 
         http_io::async_write(self().stream(), sr_,
             call_mf(&http_responder::on_write, this));
@@ -160,15 +164,13 @@ class http_responder
     }
 
 protected:
-    std::size_t id_ = 0;
     section sect_;
-
-private:
-    acceptor_config const* pconfig_ = nullptr;
+    std::size_t id_ = 0;
     router_type& rr_;
     http_proto::request_parser pr_;
     http_proto::serializer sr_;
     http_proto::response res_;
+    acceptor_config const* pconfig_ = nullptr;
 };
 
 } // http_io

example/server/main.cpp

@@ -84,32 +84,53 @@ int server_main( int argc, char* argv[] )
             http_proto::install_serializer_service(srv.services(), cfg);
         }
 
-        // Create the routes
-        // VFALCO this is a hacky WIP
-        router_type rr0;
-        rr0.get<https_redirect_responder>("/*splat");
-        router_type rr;
-        rr.get<file_responder>("/*splat", doc_root);
-
-        using workers_type = workers<executor_type,
-            worker_ssl<executor_type>>;
-
+        router_type app;
+
+        // redirect HTTP to HTTPS
+        app.use(
+            [](Request& req, Response& res)
+            {
+                if(req.port.is_ssl)
+                    return true;
+                return https_redirect_responder()(req, res);
+            });
+
+        // "/" => "/index.html"
+        app.get("/",
+            [](Request& req, Response&)
+            {
+                req.path = urls::segments_encoded_view("index.html");
+                return true;
+            });
+
+        // static route for website
+        app.get("/*",
+            file_responder{ doc_root });
+
+        using workers_type =
+            workers< executor_type, worker_ssl<executor_type> >;
+
+        // Create all our workers
         auto& vp = emplace_part<workers_type>(
-            srv,
-            srv.get_executor(),
-            1,
-            num_workers,
-            srv.get_executor(),
-            ssl_ctx,
-            rr);
+            srv, srv.get_executor(), 1, num_workers,
+            srv.get_executor(), ssl_ctx, app);
 
+        // SSL port
         vp.emplace(
             acceptor_config{ true, false },
             workers_type::acceptor_type(
                 srv.get_executor(),
                 asio::ip::tcp::endpoint(addr, 443),
                 reuse_addr));
 
+        // plain port
+        vp.emplace(
+            acceptor_config{ false, false },
+            workers_type::acceptor_type(
+                srv.get_executor(),
+                asio::ip::tcp::endpoint(addr, 80),
+                reuse_addr));
+
         srv.run();
     }
     catch( std::exception const& e )