├── src
    └── http.cpp
├── .gitignore
├── include
    └── cppcoro
    │   ├── fmt
    │       ├── type_logger.hpp
    │       └── stringable.hpp
    │   ├── http
    │       ├── http_request.hpp
    │       ├── http_response.hpp
    │       ├── http_client.hpp
    │       ├── http_server.hpp
    │       ├── http.hpp
    │       ├── request_processor.hpp
    │       ├── route_parameter.hpp
    │       ├── http_chunk_provider.hpp
    │       ├── details
    │       │   ├── router.hpp
    │       │   └── static_parser_handler.hpp
    │       ├── http_message.hpp
    │       ├── http_connection.hpp
    │       └── route_controller.hpp
    │   ├── details
    │       ├── type_index.hpp
    │       └── function_traits.hpp
    │   └── tcp
    │       └── tcp.hpp
├── examples
    ├── CMakeLists.txt
    ├── simple_co_http_server
    │   ├── CMakeLists.txt
    │   └── main.cpp
    ├── readme.cpp
    └── hello_world.cpp
├── tests
    ├── CMakeLists.txt
    ├── test_requests.cpp
    ├── test_route_controller.cpp
    ├── test_server.cpp
    └── test_chunked.cpp
├── LICENSE
├── README.md
└── CMakeLists.txt


/src/http.cpp:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | cmake-build*/
2 | .idea/
3 | 


--------------------------------------------------------------------------------
/include/cppcoro/fmt/type_logger.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <spdlog/spdlog.h>
 4 | 
 5 | namespace cppcoro {
 6 |     template <typename ClassT>
 7 |     struct type_logger {
 8 | 
 9 |     };
10 | }
11 | 


--------------------------------------------------------------------------------
/include/cppcoro/http/http_request.hpp:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @file cppcoro/http_request.hpp
 3 |  */
 4 | #pragma once
 5 | 
 6 | #include <cppcoro/http/http_message.hpp>
 7 | 
 8 | namespace cppcoro::http {
 9 |     using string_request = abstract_request<std::string>;
10 | }
11 | 


--------------------------------------------------------------------------------
/include/cppcoro/http/http_response.hpp:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @file cppcoro/http_response.hpp
 3 |  */
 4 | #pragma once
 5 | 
 6 | #include <cppcoro/http/http_message.hpp>
 7 | 
 8 | namespace cppcoro::http {
 9 |     using string_response = abstract_response<std::string>;
10 | }
11 | 


--------------------------------------------------------------------------------
/examples/CMakeLists.txt:
--------------------------------------------------------------------------------
1 | add_executable(readme readme.cpp)
2 | target_link_libraries(readme PRIVATE cppcoro::http)
3 | 
4 | add_executable(hello_world hello_world.cpp)
5 | target_link_libraries(hello_world PRIVATE cppcoro::http)
6 | 
7 | add_subdirectory(simple_co_http_server)
8 | 


--------------------------------------------------------------------------------
/examples/simple_co_http_server/CMakeLists.txt:
--------------------------------------------------------------------------------
1 | conan_cmake_run(
2 |   REQUIRES
3 |     lyra/1.4.0
4 |   BASIC_SETUP CMAKE_TARGETS
5 |   BUILD outdated)
6 | 
7 | add_executable(simple_co_http_server main.cpp)
8 | target_link_libraries(simple_co_http_server cppcoro::http CONAN_PKG::lyra)
9 | 


--------------------------------------------------------------------------------
/tests/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | FetchContent_Declare(_fetch_catch
 2 |   GIT_REPOSITORY https://github.com/catchorg/catch2
 3 |   GIT_TAG master
 4 |   )
 5 | FetchContent_MakeAvailable(_fetch_catch)
 6 | include(${_fetch_catch_SOURCE_DIR}/contrib/Catch.cmake)
 7 | 
 8 | link_libraries(cppcoro::http Catch2::Catch2)
 9 | 
10 | macro(basic_test _filename)
11 |   get_filename_component(_target ${_filename} NAME_WE)
12 |   add_executable(${_target} ${_filename})
13 |   catch_discover_tests(${_target})
14 | endmacro()
15 | 
16 | basic_test(test_requests.cpp)
17 | basic_test(test_route_controller.cpp)
18 | basic_test(test_server.cpp)
19 | basic_test(test_chunked.cpp)
20 | 


--------------------------------------------------------------------------------
/include/cppcoro/fmt/stringable.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <fmt/format.h>
 4 | 
 5 | #include <cppcoro/net/ip_endpoint.hpp>
 6 | 
 7 | namespace fmt {
 8 | 
 9 |     namespace concepts {
10 |         template<typename T>
11 |         concept stringable = requires(const T &v) {
12 |             { v.to_string() } -> std::convertible_to<std::string>;
13 |         };
14 |     }
15 | 
16 |     template <concepts::stringable StringableT>
17 |     struct formatter<StringableT> : fmt::formatter<std::string> {
18 |         template <typename FormatContext>
19 |         auto format(const StringableT &obj, FormatContext& ctx) {
20 |             return formatter<std::string>::format(obj.to_string(), ctx);
21 |         }
22 |     };
23 | }
24 | 


--------------------------------------------------------------------------------
/include/cppcoro/http/http_client.hpp:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @file cppcoro/http_server.hpp
 3 |  */
 4 | #pragma once
 5 | 
 6 | #include <cppcoro/tcp/tcp.hpp>
 7 | #include <cppcoro/http/http_connection.hpp>
 8 | #include <cppcoro/http/http_response.hpp>
 9 | #include <cppcoro/task.hpp>
10 | #include <cppcoro/operation_cancelled.hpp>
11 | 
12 | #include <utility>
13 | #include <vector>
14 | #include <iostream>
15 | 
16 | namespace cppcoro::http {
17 | 
18 |     class client : protected tcp::client
19 |     {
20 |     public:
21 |         using tcp::client::client;
22 |         using tcp::client::stop;
23 |         using tcp::client::service;
24 |         using connection_type = connection<client>;
25 | 
26 |         task<connection_type> connect(net::ip_endpoint const &endpoint) {
27 |             connection_type conn{*this, std::move(co_await tcp::client::connect(endpoint))};
28 |             co_return conn;
29 |         }
30 | 
31 |     private:
32 |         cppcoro::cancellation_source cancellation_source_;
33 |     };
34 | } // namespace cpporo::http
35 | 


--------------------------------------------------------------------------------
/include/cppcoro/details/type_index.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <cstdlib>
 4 | 
 5 | #include <tuple>
 6 | #include <type_traits>
 7 | 
 8 | namespace cppcoro::detail {
 9 | 
10 |     /**
11 |      * Useful template for resolving index of variadic template arguments
12 |      */
13 |     template<typename T, typename ... Ts>
14 |     struct type_index;
15 | 
16 |     template<typename T, typename ... Ts>
17 |     struct type_index<T, T, Ts ...>
18 |         : std::integral_constant<std::size_t, 0>
19 |     {
20 |     };
21 | 
22 |     template<typename T, typename U, typename ... Ts>
23 |     struct type_index<T, U, Ts ...>
24 |         : std::integral_constant<std::size_t, 1 + type_index<T, Ts...>::value>
25 |     {
26 |     };
27 | 
28 |     template<typename T, typename...Ts>
29 |     static constexpr std::size_t type_index_v = type_index<T, Ts...>::value;
30 | 
31 |     template<size_t idx, typename...Ts>
32 |     struct type_at
33 |     {
34 |         using type = std::tuple_element_t<idx, std::tuple<Ts...>>;
35 |     };
36 | 
37 |     template<size_t idx, typename...Ts>
38 |     using type_at_t = typename type_at<idx, Ts...>::type;
39 | }
40 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2020 Sylvain Garcia
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/include/cppcoro/http/http_server.hpp:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @file cppcoro/http_server.hpp
 3 |  */
 4 | #pragma once
 5 | 
 6 | #include <cppcoro/task.hpp>
 7 | #include <cppcoro/tcp/tcp.hpp>
 8 | #include <cppcoro/http/http_connection.hpp>
 9 | #include <cppcoro/operation_cancelled.hpp>
10 | 
11 | #include <utility>
12 | #include <vector>
13 | #include <iostream>
14 | 
15 | namespace cppcoro::http {
16 | 
17 |     class server : protected tcp::server
18 |     {
19 |     public:
20 |         using tcp::server::server;
21 |         using tcp::server::stop;
22 |         using tcp::server::service;
23 |         using connection_type = connection<server>;
24 | 
25 |         task<connection_type> listen() {
26 |             auto conn_generator = accept();
27 |             while (!cs_.is_cancellation_requested()) {
28 |                 spdlog::debug("listening for new connection on {}", socket_.local_endpoint());
29 |                 connection_type conn{*this, std::move(co_await accept())};
30 |                 spdlog::debug("{} incoming connection: {}", conn.to_string(), conn.peer_address());
31 |                 co_return conn;
32 |             }
33 |             throw operation_cancelled{};
34 |         }
35 | 
36 |     private:
37 |         cppcoro::cancellation_source cancellation_source_;
38 |     };
39 | } // namespace cpporo::http
40 | 


--------------------------------------------------------------------------------
/tests/test_requests.cpp:
--------------------------------------------------------------------------------
 1 | #define CATCH_CONFIG_MAIN
 2 | #include <catch2/catch.hpp>
 3 | 
 4 | #include <cppcoro/http/http_request.hpp>
 5 | #include <cppcoro/http/http_response.hpp>
 6 | #include <cppcoro/task.hpp>
 7 | #include <cppcoro/sync_wait.hpp>
 8 | #include <cppcoro/when_all.hpp>
 9 | #include <cppcoro/is_awaitable.hpp>
10 | #include <cppcoro/io_service.hpp>
11 | #include <cppcoro/on_scope_exit.hpp>
12 | 
13 | using namespace cppcoro;
14 | 
15 | SCENARIO("requests should be customizable", "[cppcoro-http][messages][request]") {
16 |     io_service ios;
17 |     GIVEN("A simple string request") {
18 |         http::string_request req{http::method::post, "/", "hello"};
19 |         WHEN("The http header is built") {
20 |             auto header = req.build_header();
21 |             THEN("It can be parsed") {
22 |                 (void) sync_wait(when_all([&]() -> task<> {
23 |                     auto _ = on_scope_exit([&] {
24 |                         ios.stop();
25 |                     });
26 |                     http::string_request result;
27 |                     http::request_parser parser;
28 |                     parser.parse(header);
29 |                     REQUIRE(!parser);
30 |                     parser.parse(req.body_access);
31 |                     REQUIRE(parser);
32 |                     co_await parser.load(result);
33 |                     REQUIRE(result.method == http::method::post);
34 |                     REQUIRE(result.body_access == "hello");
35 |                     AND_THEN("The parsed request should give same header") {
36 |                         REQUIRE(result.build_header() == header);
37 |                     }
38 |                 }(),
39 |                 [&]() -> task<> {
40 |                     ios.process_events();
41 |                     co_return;
42 |                 }()));
43 |             }
44 |         }
45 |     }
46 | }
47 | 


--------------------------------------------------------------------------------
/include/cppcoro/http/http.hpp:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @file cppcoro/http.hpp
 3 |  */
 4 | #pragma once
 5 | 
 6 | #include <map>
 7 | #include <string>
 8 | 
 9 | #include <spdlog/spdlog.h>
10 | #include <spdlog/sinks/stdout_color_sinks.h>
11 | 
12 | namespace cppcoro::http {
13 | 
14 |     namespace detail {
15 |         #include <http_parser.h>
16 |     }
17 | 
18 |     enum class method
19 |     {
20 |         get = detail::HTTP_GET,
21 |         put = detail::HTTP_PUT,
22 |         del = detail::HTTP_DELETE,
23 |         post = detail::HTTP_POST,
24 |         head = detail::HTTP_HEAD,
25 |         options = detail::HTTP_OPTIONS,
26 |         patch = detail::HTTP_PATCH,
27 |         unknown
28 |     };
29 | 
30 |     using status = detail::http_status;
31 |     using headers = std::map<std::string, std::string>;
32 | 
33 |     namespace logging {
34 |         static inline spdlog::level_t log_level = spdlog::level::warn;
35 |         constexpr auto logger_name = "cppcoro::http";
36 |         inline static auto logger = [] () -> std::shared_ptr<spdlog::logger> {
37 |             if (auto logger = spdlog::get(logger_name);
38 |                 logger) {
39 |                 return logger;
40 |             }
41 |             return spdlog::stdout_color_mt(logger_name);
42 |         }();
43 |         template <typename IdT>
44 |         auto logger_id(IdT &&id) {
45 |             return fmt::format("{}::{}", logger_name, std::forward<IdT>(id));
46 |         }
47 |         template <typename IdT>
48 |         auto get_logger(IdT &&id) {
49 |             const auto _id = logger_id(std::forward<IdT>(id));
50 |             if (auto _logger = spdlog::get(_id);
51 |                 _logger) {
52 |                 return _logger;
53 |             }
54 |             auto &sinks = logging::logger->sinks();
55 |             auto this_logger = std::make_shared<spdlog::logger>(_id, begin(sinks), end(sinks));
56 |             this_logger->set_level(spdlog::level::level_enum(log_level.load(std::memory_order_relaxed)));
57 |             return this_logger;
58 |         }
59 |         template <typename IdT>
60 |         auto drop_logger(IdT &&id) {
61 |             spdlog::drop(logger_id(std::forward<IdT>(id)));
62 |         }
63 |     }
64 | }
65 | 


--------------------------------------------------------------------------------
/include/cppcoro/http/request_processor.hpp:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @file cppcoro/http/route_controller.hpp
 3 |  * @author Sylvain Garcia <garcia.6l20@gmail.com>
 4 |  */
 5 | #pragma once
 6 | 
 7 | #include <cppcoro/http/http_server.hpp>
 8 | #include <cppcoro/async_scope.hpp>
 9 | 
10 | namespace cppcoro::http {
11 | 
12 |     template<typename SessionT, typename ProcessorT>
13 |     class request_processor : public server
14 |     {
15 |     public:
16 |         using session_type = SessionT;
17 |         using server::server;
18 | 
19 |         task<> serve() {
20 |             async_scope scope;
21 |             try {
22 |                 while (true) {
23 |                     auto conn = co_await listen();
24 |                     scope.spawn([](server *srv, http::server::connection_type conn) mutable -> task<> {
25 |                         session_type session{};
26 |                         http::string_request default_request;
27 |                         auto init_request = [&](const http::request_parser &parser) -> http::detail::base_request& {
28 |                             auto *request = static_cast<ProcessorT*>(srv)->prepare(parser, session);
29 |                             if (!request) {
30 |                                 return default_request;
31 |                             }
32 |                             return *request;
33 |                         };
34 |                         while (true) {
35 |                             try {
36 |                                 // wait next connection request
37 |                                 auto req = co_await conn.next(init_request);
38 |                                 if (!req)
39 |                                     break; // connection closed
40 |                                 // process and send the response
41 |                                 co_await conn.send(co_await static_cast<ProcessorT*>(srv)->process(*req));
42 |                             } catch (std::system_error &err) {
43 |                                 if (err.code() == std::errc::connection_reset) {
44 |                                     break; // connection reset by peer
45 |                                 } else {
46 |                                     throw err;
47 |                                 }
48 |                             } catch (operation_cancelled &) {
49 |                                 break;
50 |                             }
51 |                         }
52 |                     }(this, std::move(conn)));
53 |                 }
54 |             } catch (operation_cancelled &) {}
55 |             co_await scope.join();
56 |         }
57 |     };
58 | }
59 | 


--------------------------------------------------------------------------------
/tests/test_route_controller.cpp:
--------------------------------------------------------------------------------
 1 | #define CATCH_CONFIG_MAIN
 2 | 
 3 | #include <catch2/catch.hpp>
 4 | 
 5 | #include <fmt/format.h>
 6 | 
 7 | #include <cppcoro/http/route_controller.hpp>
 8 | #include <cppcoro/http/http_client.hpp>
 9 | #include <cppcoro/io_service.hpp>
10 | #include <cppcoro/sync_wait.hpp>
11 | #include <cppcoro/when_all.hpp>
12 | #include <cppcoro/on_scope_exit.hpp>
13 | 
14 | using namespace cppcoro;
15 | 
16 | struct session
17 | {
18 |     int id = std::rand();
19 | };
20 | 
21 | using hello_controller_def = http::route_controller<R"(/hello/(\w+))",
22 |     session,
23 |     http::string_request,
24 |     struct hello_controller>;
25 | 
26 | struct hello_controller : hello_controller_def
27 | {
28 |     using hello_controller_def::hello_controller_def;
29 | 
30 |     auto on_post(std::string_view who) -> task<http::string_response> {
31 |         fmt::print("post on {}\n", session().id);
32 |         co_return http::string_response{http::status::HTTP_STATUS_OK, fmt::format("post: {}", who)};
33 |     }
34 |     auto on_get(const std::string &who) -> task<http::string_response> {
35 |         fmt::print("get on {}\n", session().id);
36 |         co_return http::string_response{http::status::HTTP_STATUS_OK, fmt::format("get: {}", who)};
37 |     }
38 | };
39 | 
40 | SCENARIO("route controller are easy to use", "[cppcoro-http][router]") {
41 |     cppcoro::io_service ios;
42 |     static const auto test_endpoint = net::ip_endpoint::from_string("127.0.0.1:4242");
43 |     GIVEN("A simple route controller") {
44 |         http::controller_server<session, hello_controller> server{ios,
45 |                                                                   *test_endpoint};
46 |         http::client client{ios};
47 | 
48 |         (void) sync_wait(when_all(
49 |             [&]() -> task<> {
50 |                 auto _ = on_scope_exit([&] {
51 |                     ios.stop();
52 |                 });
53 |                 co_await server.serve();
54 |             }(),
55 |             [&]() -> task<> {
56 |                 auto _ = on_scope_exit([&] {
57 |                     server.stop();
58 |                 });
59 |                 using namespace std::chrono_literals;
60 |                 auto conn = co_await client.connect(*test_endpoint);
61 |                 auto resp = co_await conn.post("/hello/world");
62 |                 REQUIRE(co_await resp->read_body() == "post: world");
63 |                 resp = co_await conn.get("/hello/world");
64 |                 REQUIRE(co_await resp->read_body() == "get: world");
65 |             }(),
66 |             [&]() -> task<> {
67 |                 ios.process_events();
68 |                 co_return;
69 |             }()
70 |         ));
71 |     }
72 | }
73 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # CppCoro Http - http coroutine library for C++
 2 | 
 3 | > :warning: After few experiments the API in master is not satifying enought.
 4 |             The expected API should be closest to the [router-v2](https://github.com/Garcia6l20/cppcoro-http/tree/feature/router-v2) branch.
 5 |             But it has some strange multithreading issues I'll not investigate
 6 |             since [cppcoro](https://github.com/lewissbaker/cppcoro) looks inactive (library fixes needed).
 7 | 
 8 | The 'cppcoro-http' provides a set of classes for creating http servers/clients.
 9 | It is built on top of [cppcoro](https://github.com/lewissbaker/cppcoro) library.
10 | 
11 | ## HTTP Server
12 | 
13 | - example:
14 | 
15 | ```c++
16 | struct session {
17 |     int id = std::rand();
18 | };
19 | 
20 | using hello_controller_def = http::route_controller<
21 |     R"(/hello/(\w+))",  // route definition
22 |     session,
23 |     http::string_request,
24 |     struct hello_controller>;
25 | 
26 | struct hello_controller : hello_controller_def
27 | {
28 |     using hello_controller_def::hello_controller_def;
29 |     // method handlers
30 |     auto on_post(std::string_view who) -> task<http::string_response> {
31 |         co_return http::string_response{http::status::HTTP_STATUS_OK,
32 |                                  fmt::format("post at {}: hello {}", session().id, who)};
33 |     }
34 |     auto on_get(std::string_view who) -> task<http::string_response> {
35 |         co_return http::string_response{http::status::HTTP_STATUS_OK,
36 |                                  fmt::format("get at {}: hello {}", session().id, who)};
37 |     }
38 | };
39 | 
40 | io_service service;
41 | 
42 | auto do_serve = [&]() -> task<> {
43 |     auto _ = on_scope_exit([&] {
44 |         service.stop();
45 |     });
46 |     http::controller_server<session, hello_controller> server{
47 |         service,
48 |         *net::ip_endpoint::from_string("127.0.0.1:4242")};
49 |     co_await server.serve();
50 | };
51 | (void) sync_wait(when_all(
52 |     do_serve(),
53 |     [&]() -> task<> {
54 |         service.process_events();
55 |         co_return;
56 |     }()));
57 | ```
58 | 
59 | ## Building
60 | 
61 | > requirements:
62 | > - GCC11
63 | > - linux kernel version >= 5.5
64 | > - my [cppcoro](https://github.com/Garcia6l20/cppcoro) fork
65 | 
66 | ```bash
67 | mkdir build && cd build
68 | cmake -DBUILD_EXAMPLES=ON ..
69 | make -j
70 | ```
71 | 
72 | ## Development
73 | 
74 | You can also use cppcoro without installing it for development purposes:
75 | 
76 | ```bash
77 | cmake -DCPPCORO_DEVEL=ON ..
78 | ```
79 | 
80 | ## Examples
81 | 
82 | - *examples/readme.cpp*: Example in this README.
83 | - *examples/hello_world.cpp*: Basic showcase.
84 | - *examples/simple_co_http_server*: Same as `python3 -m http.server` in cppcoro.
85 | 
86 | ## TODO
87 | 
88 | - [x] chunked transfers
89 | - [ ] ssl support
90 | - [ ] ...
91 | 


--------------------------------------------------------------------------------
/include/cppcoro/http/route_parameter.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <algorithm>
 4 | #include <string>
 5 | #include <filesystem>
 6 | #include <vector>
 7 | #include <charconv>
 8 | 
 9 | #include <ctll.hpp>
10 | 
11 | namespace cppcoro::http {
12 | 
13 |     template <typename T>
14 |     struct route_parameter;
15 | 
16 |     template <>
17 |     struct route_parameter<std::string> {
18 |         static constexpr int group_count() { return 0; }
19 |         static std::string load(const std::string_view& input) {
20 |             return {input.data(), input.data() + input.size()};
21 |         }
22 | 
23 |         static constexpr auto pattern = ctll::fixed_string{R"(.+(?=/)|.+)"};
24 |     };
25 | 
26 |     template <>
27 |     struct route_parameter<std::string_view> {
28 |         static constexpr int group_count() { return 0; }
29 |         static std::string_view load(const std::string_view& input) {
30 |             return {input.data(), input.size()};
31 |         }
32 | 
33 |         static constexpr auto pattern = ctll::fixed_string{R"(.+(?=/)|.+)"};
34 |     };
35 | 
36 |     template <>
37 |     struct route_parameter<std::filesystem::path> {
38 |         static constexpr int group_count() { return 0; }
39 |         static std::filesystem::path load(const std::string_view& input) {
40 |             return {input.data()};
41 |         }
42 |         static constexpr auto pattern = ctll::fixed_string{R"(.+)"};
43 |     };
44 | 
45 |     template <>
46 |     struct route_parameter<int> {
47 |         static constexpr int group_count() { return 0; }
48 |         static int load(const std::string_view &input) {
49 |             int result = 0;
50 |             std::from_chars(input.data(), input.data() + input.size(), result);
51 |             return result;
52 |         }
53 |         static constexpr auto pattern = ctll::fixed_string{R"(\d+)"};
54 |     };
55 | 
56 |     template <>
57 |     struct route_parameter<double> {
58 |         static constexpr int group_count() { return 0; }
59 |         static double load(const std::string_view& input) {
60 |             double result = 0;
61 |             std::from_chars(input.data(), input.data() + input.size(), result);
62 |             return result;
63 |         }
64 |         static constexpr auto pattern = ctll::fixed_string{R"(\d+\.?\d*)"};
65 |     };
66 | 
67 |     template <>
68 |     struct route_parameter<bool> {
69 |         static bool load(const std::string_view& input) {
70 |             static const std::vector<std::string> true_values = {"yes", "on", "true"};
71 |             return std::any_of(true_values.begin(), true_values.end(), [&input](auto&&elem) {
72 |                 return std::equal(elem.begin(), elem.end(), input.begin(), input.end(), [](char left, char right) {
73 |                     return tolower(left) == tolower(right);
74 |                 });
75 |             });
76 |         }
77 |         static constexpr auto pattern = ctll::fixed_string{R"(\w+)"};
78 |     };
79 | 
80 | }  // namespace xdev::net
81 | 


--------------------------------------------------------------------------------
/CMakeLists.txt:
--------------------------------------------------------------------------------
  1 | cmake_minimum_required(VERSION 3.17)
  2 | project(cppcoro_http)
  3 | 
  4 | set(CMAKE_CXX_STANDARD 20)
  5 | set(CMAKE_CXX_STANDARD_REQUIRED  ON)
  6 | 
  7 | if(NOT EXISTS "${CMAKE_BINARY_DIR}/conan.cmake")
  8 |   message(STATUS "Downloading conan.cmake from https://github.com/conan-io/cmake-conan")
  9 |   file(DOWNLOAD "https://github.com/conan-io/cmake-conan/raw/v0.15/conan.cmake"
 10 |     "${CMAKE_BINARY_DIR}/conan.cmake")
 11 | endif()
 12 | include("${CMAKE_BINARY_DIR}/conan.cmake")
 13 | 
 14 | 
 15 | include(FetchContent)
 16 | 
 17 | #
 18 | # cppcoro
 19 | #
 20 | option(CPPCORO_DEVEL "Fetch cppcoro for development" ON)
 21 | if(CPPCORO_DEVEL)
 22 |   FetchContent_Declare(_fetch_cppcoro
 23 |     GIT_REPOSITORY https://github.com/Garcia6l20/cppcoro
 24 |     )
 25 |   FetchContent_MakeAvailable(_fetch_cppcoro)
 26 | else()
 27 |   find_package(cppcoro REQUIRED)
 28 | endif()
 29 | 
 30 | #
 31 | # nodejs/http_parser
 32 | #
 33 | FetchContent_Declare(_fetch_http_parser
 34 |   GIT_REPOSITORY https://github.com/nodejs/http-parser
 35 |   GIT_TAG master
 36 |   CONFIGURE_COMMAND ""
 37 |   INSTALL_COMMAND ""
 38 |   BUILD_COMMAND ""
 39 |   )
 40 | FetchContent_MakeAvailable(_fetch_http_parser)
 41 | FetchContent_GetProperties(_fetch_http_parser)
 42 | if(NOT EXISTS ${_fetch_http_parser_SOURCE_DIR}/http_parser.c)
 43 | endif()
 44 | add_library(http_parser STATIC
 45 |   ${_fetch_http_parser_SOURCE_DIR}/http_parser.c
 46 |   ${_fetch_http_parser_SOURCE_DIR}/http_parser.h
 47 |   )
 48 | target_include_directories(http_parser PUBLIC ${_fetch_http_parser_SOURCE_DIR}/)
 49 | add_library(http_parser::http_parser ALIAS http_parser)
 50 | 
 51 | conan_cmake_run(
 52 |   REQUIRES
 53 |     fmt/7.0.1
 54 |     spdlog/1.7.0
 55 |     ctre/2.8.2
 56 |   BASIC_SETUP CMAKE_TARGETS
 57 |   BUILD outdated)
 58 | 
 59 | #
 60 | # cppcoro/http
 61 | #
 62 | add_library(${PROJECT_NAME} STATIC
 63 |   include/cppcoro/tcp/tcp.hpp
 64 |   include/cppcoro/http/http.hpp
 65 |   include/cppcoro/http/http_message.hpp
 66 |   include/cppcoro/http/http_request.hpp
 67 |   include/cppcoro/http/http_response.hpp
 68 |   include/cppcoro/http/http_server.hpp
 69 |   include/cppcoro/http/http_client.hpp
 70 |   include/cppcoro/http/http_connection.hpp
 71 |   include/cppcoro/http/request_processor.hpp
 72 |   include/cppcoro/http/route_controller.hpp
 73 |   include/cppcoro/http/route_parameter.hpp
 74 | 
 75 |   include/cppcoro/http/details/router.hpp
 76 |   include/cppcoro/http/details/static_parser_handler.hpp
 77 | 
 78 |   include/cppcoro/details/function_traits.hpp
 79 |   include/cppcoro/details/type_index.hpp
 80 | 
 81 |   src/http.cpp
 82 |   )
 83 | target_include_directories(${PROJECT_NAME} PUBLIC include)
 84 | target_link_libraries(${PROJECT_NAME} PUBLIC
 85 |   cppcoro::cppcoro
 86 |   http_parser::http_parser
 87 |   CONAN_PKG::ctre
 88 |   CONAN_PKG::fmt
 89 |   CONAN_PKG::spdlog)
 90 | target_precompile_headers(${PROJECT_NAME} INTERFACE
 91 |   <ctre/functions.hpp>
 92 |   <ctll/fixed_string.hpp>
 93 |   )
 94 | add_library(cppcoro::http ALIAS ${PROJECT_NAME})
 95 | 
 96 | option(BUILD_EXAMPLES "Build examples" ON)
 97 | if (BUILD_EXAMPLES)
 98 |   add_subdirectory(examples)
 99 | endif()
100 | 
101 | enable_testing()
102 | if (BUILD_TESTING)
103 |   add_subdirectory(tests)
104 | endif()
105 | 


--------------------------------------------------------------------------------
/examples/readme.cpp:
--------------------------------------------------------------------------------
 1 | #include <cppcoro/task.hpp>
 2 | #include <cppcoro/on_scope_exit.hpp>
 3 | #include <cppcoro/sync_wait.hpp>
 4 | #include <cppcoro/when_all.hpp>
 5 | #include <cppcoro/async_scope.hpp>
 6 | #include <cppcoro/http/http_server.hpp>
 7 | 
 8 | #include <fmt/format.h>
 9 | #include <cppcoro/http/route_controller.hpp>
10 | #include <cppcoro/http/http_chunk_provider.hpp>
11 | 
12 | using namespace cppcoro;
13 | 
14 | int main() {
15 |     struct session {
16 |         int id = std::rand();
17 |     };
18 | 
19 |     using hello_controller_def = http::route_controller<
20 |         R"(/hello/(\w+))",  // route definition
21 |         session,
22 |         http::string_request,
23 |         struct hello_controller>;
24 | 
25 |     struct hello_controller : hello_controller_def
26 |     {
27 |         using hello_controller_def::hello_controller_def;
28 |         // method handlers
29 |         auto on_post(std::string_view who) -> task<http::string_response> {
30 |             co_return http::string_response{http::status::HTTP_STATUS_OK,
31 |                                      fmt::format("post at {}: hello {}", session().id, who)};
32 |         }
33 |         auto on_get(std::string_view who) -> task<http::string_response> {
34 |             co_return http::string_response{http::status::HTTP_STATUS_OK,
35 |                                      fmt::format("get at {}: hello {}", session().id, who)};
36 |         }
37 |     };
38 | 
39 |     struct hello_chunk_provider : http::abstract_chunk_base {
40 |         std::string_view who;
41 |         using http::abstract_chunk_base::abstract_chunk_base;
42 |         hello_chunk_provider(io_service& service, std::string_view who) : http::abstract_chunk_base{service}, who{who} {}
43 |         async_generator<std::string_view> read(size_t) {
44 |             co_yield "hello\n";
45 |             co_yield fmt::format("{}\n", who);
46 |         }
47 |     };
48 |     using hello_chunked_response = http::abstract_response<hello_chunk_provider>;
49 | 
50 |     using hello_chunk_controller_def = http::route_controller<
51 |         R"(/chunk/(\w+))",  // route definition
52 |         session,
53 |         http::string_request,
54 |         struct hello_chunk_controller>;
55 | 
56 |     struct hello_chunk_controller : hello_chunk_controller_def
57 |     {
58 |         using hello_chunk_controller_def::hello_chunk_controller_def;
59 |         // method handlers
60 |         task<hello_chunked_response> on_get(std::string_view who) {
61 |             co_return hello_chunked_response{http::status::HTTP_STATUS_OK,
62 |                                              hello_chunk_provider {service(), who}};
63 |         }
64 |     };
65 | 
66 |     io_service service;
67 | 
68 |     auto do_serve = [&]() -> task<> {
69 |         auto _ = on_scope_exit([&] {
70 |             service.stop();
71 |         });
72 |         http::controller_server<
73 |             session,
74 |             hello_controller,
75 |             hello_chunk_controller> server {
76 |             service,
77 |             *net::ip_endpoint::from_string("127.0.0.1:4242")
78 |         };
79 |         co_await server.serve();
80 |     };
81 |     (void) sync_wait(when_all(
82 |         do_serve(),
83 |         [&]() -> task<> {
84 |             service.process_events();
85 |             co_return;
86 |         }()));
87 |     return 0;
88 | }
89 | 


--------------------------------------------------------------------------------
/tests/test_server.cpp:
--------------------------------------------------------------------------------
 1 | #define CATCH_CONFIG_MAIN
 2 | #include <catch2/catch.hpp>
 3 | 
 4 | #include <fmt/format.h>
 5 | 
 6 | #include <cppcoro/http/http_server.hpp>
 7 | #include <cppcoro/http/http_client.hpp>
 8 | #include <cppcoro/io_service.hpp>
 9 | #include <cppcoro/sync_wait.hpp>
10 | #include <cppcoro/when_all.hpp>
11 | #include <cppcoro/on_scope_exit.hpp>
12 | #include <cppcoro/http/route_controller.hpp>
13 | #include <thread>
14 | 
15 | using namespace cppcoro;
16 | 
17 | namespace rng = std::ranges;
18 | 
19 | constexpr auto test_thread_count = 3;
20 | constexpr auto test_endpoint = "127.0.0.1:4242";
21 | 
22 | SCENARIO("echo server should work", "[cppcoro-http][server][echo]") {
23 |     http::logging::log_level = spdlog::level::debug;
24 | 
25 |     io_service ios;
26 | 
27 |     struct session {};
28 | 
29 |     using echo_route_controller_def = http::route_controller<
30 |         R"(/echo)",  // route definition
31 |         session,
32 |         http::string_request,
33 |         struct echo_controller>;
34 | 
35 |     struct echo_controller : echo_route_controller_def
36 |     {
37 |         using echo_route_controller_def::echo_route_controller_def;
38 |         auto on_get() -> task<http::string_response> {
39 |             co_return http::string_response {http::status::HTTP_STATUS_OK,
40 |                                      fmt::format("{}", co_await request().read_body())};
41 |         }
42 |     };
43 |     using echo_server = http::controller_server<session, echo_controller>;
44 |     echo_server server{ios, *net::ip_endpoint::from_string(test_endpoint)};
45 |     std::vector<std::thread> tp{test_thread_count};
46 |     auto start_threads = [&tp, &ios] {
47 |         rng::generate(tp, [&ios] {
48 |             return std::thread{[&] {
49 |                 ios.process_events();
50 |             }};
51 |         });
52 |     };
53 |     auto join_treads = [&tp] {
54 |         rng::for_each(tp, [](auto &&t) {
55 |             t.join();
56 |         });
57 |     };
58 |     GIVEN("An echo server") {
59 |         WHEN("...") {
60 |             http::client client{ios};
61 |             sync_wait(when_all(
62 |             [&]() -> task<> {
63 |                 auto _ = on_scope_exit([&] {
64 |                     ios.stop();
65 |                 });
66 |                 co_await server.serve();
67 |             } (),
68 |             [&]() -> task<> {
69 |                 auto _ = on_scope_exit([&] {
70 |                     server.stop();
71 |                 });
72 |                 auto conn = co_await client.connect(*net::ip_endpoint::from_string(test_endpoint));
73 |                 auto response = co_await conn.get("/echo", "hello");
74 |                 REQUIRE(response->status == http::status::HTTP_STATUS_OK);
75 |                 REQUIRE(co_await response->read_body() == "hello");
76 |             }(),
77 | //            [&]() -> task<> {
78 | //                auto conn = co_await client.connect(*net::ip_endpoint::from_string(test_endpoint));
79 | //                auto response = co_await conn.get("/echo", "olleh");
80 | //                REQUIRE(response->status == http::status::HTTP_STATUS_OK);
81 | //                REQUIRE(co_await response->read_body() == "olleh");
82 | //            }(),
83 |             [&]() -> task<> {
84 |                 start_threads();
85 |                 co_return;
86 |             }()));
87 |             join_treads();
88 |         }
89 |     }
90 | }
91 | 


--------------------------------------------------------------------------------
/include/cppcoro/tcp/tcp.hpp:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * @file cppcoro/tcp.hpp
  3 |  */
  4 | #pragma once
  5 | 
  6 | #include <cppcoro/io_service.hpp>
  7 | #include <cppcoro/net/socket.hpp>
  8 | #include <cppcoro/cancellation_source.hpp>
  9 | 
 10 | #include <utility>
 11 | 
 12 | namespace cppcoro {
 13 |     namespace net {
 14 |         template<bool bind = true>
 15 |         auto create_tcp_socket(io_service &ios, const ip_endpoint &endpoint) {
 16 |             auto sock = socket{endpoint.is_ipv4() ? socket::create_tcpv4(ios) : socket::create_tcpv6(ios)};
 17 |             if constexpr (bind) {
 18 |                 sock.bind(endpoint);
 19 |             }
 20 |             return sock;
 21 |         }
 22 |     }
 23 |     namespace tcp {
 24 |         class connection
 25 |         {
 26 |         public:
 27 |             connection(connection &&other) noexcept
 28 |                 : sock_{std::move(other.sock_)}, ct_{std::move(other.ct_)} {}
 29 | 
 30 |             connection(const connection &) = delete;
 31 | 
 32 |             connection(net::socket socket, cancellation_token ct)
 33 |                 : sock_{std::move(socket)},
 34 |                   ct_{std::move(ct)} {
 35 |             }
 36 | 
 37 |             [[nodiscard]] const net::ip_endpoint &peer_address() const {
 38 |                 return sock_.remote_endpoint();
 39 |             }
 40 | 
 41 |             [[nodiscard]] const auto &socket() const { return sock_; }
 42 | 
 43 |         protected:
 44 |             net::socket sock_;
 45 |             cancellation_token ct_;
 46 |         };
 47 | 
 48 |         class server
 49 |         {
 50 |         public:
 51 |             server(server &&other) noexcept: ios_{other.ios_}, endpoint_{std::move(other.endpoint_)},
 52 |                                              socket_{std::move(other.socket_)}, cs_{other.cs_} {}
 53 | 
 54 |             server(const server &) = delete;
 55 | 
 56 |             server(io_service &ios, const net::ip_endpoint &endpoint)
 57 |                 : ios_{ios}, endpoint_{endpoint}, socket_{net::create_tcp_socket<true>(ios, endpoint_)} {
 58 |                 socket_.listen();
 59 |             }
 60 | 
 61 |             task<connection> accept() {
 62 |                 auto sock = net::create_tcp_socket<false>(ios_, endpoint_);
 63 |                 co_await socket_.accept(sock, cs_.token());
 64 |                 co_return connection{std::move(sock), cs_.token()};
 65 |             }
 66 | 
 67 |             void stop() {
 68 |                 cs_.request_cancellation();
 69 |             }
 70 | 
 71 |             auto token() noexcept { return cs_.token(); }
 72 | 
 73 |             auto &service() noexcept { return ios_; }
 74 | 
 75 |         protected:
 76 |             io_service &ios_;
 77 |             net::ip_endpoint endpoint_;
 78 |             net::socket socket_;
 79 |             cancellation_source cs_;
 80 |         };
 81 | 
 82 |         class client
 83 |         {
 84 |         public:
 85 |             client(client &&other) noexcept: ios_{other.ios_}, cs_{other.cs_} {}
 86 | 
 87 |             client(const client &) = delete;
 88 | 
 89 |             client(io_service &ios)
 90 |                 : ios_{ios} {
 91 |             }
 92 | 
 93 |             task<connection> connect(net::ip_endpoint const&endpoint) {
 94 |                 auto sock = net::create_tcp_socket<false>(ios_, endpoint);
 95 |                 co_await sock.connect(endpoint, cs_.token());
 96 |                 co_return connection{std::move(sock), cs_.token()};
 97 |             }
 98 | 
 99 |             void stop() {
100 |                 cs_.request_cancellation();
101 |             }
102 | 
103 |             auto &service() noexcept { return ios_; }
104 | 
105 |         protected:
106 |             io_service &ios_;
107 |             cancellation_source cs_;
108 |         };
109 |     }
110 | }


--------------------------------------------------------------------------------
/include/cppcoro/http/http_chunk_provider.hpp:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * @file cppcoro/http/http_chunk_provider.hpp
  3 |  * @author Garcia Sylvain <garcia.6l20@gmail.com>
  4 |  */
  5 | #pragma once
  6 | 
  7 | #include <cppcoro/io_service.hpp>
  8 | #include <cppcoro/async_generator.hpp>
  9 | #include <cppcoro/read_only_file.hpp>
 10 | #include <cppcoro/write_only_file.hpp>
 11 | 
 12 | #include <cppcoro/http/http_message.hpp>
 13 | 
 14 | namespace cppcoro::http {
 15 | 
 16 |     /**
 17 |      * @brief Abstract chunk base.
 18 |      *
 19 |      * Implements base requirements for chunk providers/processors (default service ctor, move ctor & assignment op).
 20 |      */
 21 |     class abstract_chunk_base
 22 |     {
 23 |         std::reference_wrapper<io_service> service_;
 24 |     public:
 25 |         // needed for default construction
 26 |         abstract_chunk_base(io_service &service) noexcept: service_{service} {}
 27 | 
 28 |         abstract_chunk_base(abstract_chunk_base &&other) noexcept = default;
 29 | 
 30 |         abstract_chunk_base &operator=(abstract_chunk_base &&other) noexcept = default;
 31 | 
 32 |     protected:
 33 |         auto &service() { return service_; }
 34 |     };
 35 | 
 36 |     /**
 37 |      * @brief Read only file chunk provider.
 38 |      *
 39 |      * Chunk provider implementation for read_only_file access.
 40 |      */
 41 |     struct read_only_file_chunk_provider : http::abstract_chunk_base
 42 |     {
 43 |         using abstract_chunk_base::abstract_chunk_base;
 44 | 
 45 |         std::string path_;
 46 | 
 47 |         read_only_file_chunk_provider(io_service &service, std::string_view path) noexcept:
 48 |             abstract_chunk_base{service}, path_{path} {}
 49 | 
 50 |         async_generator<std::string_view> read(size_t chunk_size) {
 51 |             if (!path_.empty()) {
 52 |                 auto f = read_only_file::open(service(), path_);
 53 |                 std::string buffer;
 54 |                 buffer.resize(chunk_size);
 55 |                 uint64_t offset = 0;
 56 |                 auto to_send = f.size();
 57 |                 size_t res;
 58 |                 do {
 59 |                     res = co_await f.read(offset, buffer.data(), chunk_size);
 60 |                     to_send -= res;
 61 |                     offset += res;
 62 |                     co_yield std::string_view{buffer.data(), res};
 63 |                 } while (to_send);
 64 |             }
 65 |         }
 66 |     };
 67 | 
 68 |     static_assert(std::constructible_from<read_only_file_chunk_provider, io_service &>);
 69 |     static_assert(http::detail::ro_chunked_body<read_only_file_chunk_provider>);
 70 | 
 71 |     using read_only_file_chunked_response = http::abstract_response<read_only_file_chunk_provider>;
 72 |     using read_only_file_chunked_request = http::abstract_request<read_only_file_chunk_provider>;
 73 | 
 74 |     /**
 75 |      * @brief Write only file chunk processor.
 76 |      *
 77 |      * Chunk processor implementation for write_only_file access.
 78 |      */
 79 |     struct write_only_file_processor : abstract_chunk_base
 80 |     {
 81 |         using abstract_chunk_base::abstract_chunk_base;
 82 | 
 83 |         void init(std::string_view path) {
 84 |             file_.emplace(write_only_file::open(service(), path, file_open_mode::create_always));
 85 |         }
 86 | 
 87 |         std::optional<write_only_file> file_;
 88 |         size_t offset = 0;
 89 | 
 90 |         task<size_t> write(std::string_view chunk) {
 91 |             assert(file_);
 92 |             auto size = co_await file_->write(offset, chunk.data(), chunk.size());
 93 |             offset += size;
 94 |             co_return size;
 95 |         }
 96 |     };
 97 | 
 98 | 
 99 |     static_assert(std::constructible_from<write_only_file_processor, io_service &>);
100 |     static_assert(detail::wo_chunked_body<write_only_file_processor>);
101 | 
102 |     using write_only_file_chunked_response = abstract_response<write_only_file_processor>;
103 |     using write_only_file_chunked_request = abstract_request<write_only_file_processor>;
104 | }
105 | 


--------------------------------------------------------------------------------
/include/cppcoro/details/function_traits.hpp:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | 
  3 | #include <functional>
  4 | 
  5 | namespace cppcoro::detail {
  6 | 
  7 |     namespace function_detail {
  8 | 
  9 |         struct parameters_tuple_all_enabled
 10 |         {
 11 |             template<typename T>
 12 |             static constexpr bool enabled = true;
 13 |         };
 14 | 
 15 |         template<typename...ArgsT>
 16 |         struct parameters_tuple_disable
 17 |         {
 18 |             template<typename T>
 19 |             static constexpr bool enabled = !std::disjunction_v<std::is_same<std::remove_cvref_t<T>, std::remove_cvref_t<ArgsT>>...>;
 20 |         };
 21 | 
 22 |         template<typename Ret, typename Cls, typename IsMutable, typename IsLambda, typename... Args>
 23 |         struct types
 24 |         {
 25 |             using is_mutable = IsMutable;
 26 |             using is_lambda = IsLambda;
 27 | 
 28 |             static constexpr auto is_function() { return !is_lambda(); }
 29 | 
 30 |             enum
 31 |             {
 32 |                 arity = sizeof...(Args)
 33 |             };
 34 | 
 35 |             using return_type = Ret;
 36 | 
 37 |             using tuple_type = std::tuple<Args...>;
 38 | 
 39 |             template<size_t i>
 40 |             struct arg
 41 |             {
 42 |                 using type = typename std::tuple_element<i, tuple_type>::type;
 43 |                 using clean_type = std::remove_cvref_t<type>;
 44 |             };
 45 | 
 46 |             using function_type = std::function<Ret(Args...)>;
 47 | 
 48 |             template<typename Predicate = parameters_tuple_all_enabled>
 49 |             struct parameters_tuple
 50 |             {
 51 | 
 52 |                 template<typename FirstT, typename...RestT>
 53 |                 static constexpr auto __make_tuple() {
 54 |                     if constexpr (!sizeof...(RestT)) {
 55 |                         if constexpr (Predicate::template enabled<FirstT>)
 56 |                             return std::make_tuple<FirstT>({});
 57 |                         else return std::tuple();
 58 |                     } else {
 59 |                         if constexpr (Predicate::template enabled<FirstT>)
 60 |                             return std::tuple_cat(std::make_tuple<FirstT>({}), __make_tuple<RestT...>());
 61 |                         else return __make_tuple<RestT...>();
 62 |                     }
 63 |                 }
 64 | 
 65 |                 struct _make
 66 |                 {
 67 |                     constexpr auto operator()() {
 68 |                         if constexpr (sizeof...(Args) == 0)
 69 |                             return std::make_tuple();
 70 |                         else return __make_tuple<Args...>();
 71 |                     }
 72 |                 };
 73 | 
 74 |                 static constexpr auto make() {
 75 |                     return _make{}();
 76 |                 }
 77 | 
 78 |                 using tuple_type = std::invoke_result_t<_make>;
 79 |             };
 80 |         };
 81 |     }
 82 | 
 83 |     template<class T>
 84 |     struct function_traits
 85 |         : function_traits<decltype(&std::decay_t<T>::operator())>
 86 |     {
 87 |     };
 88 | 
 89 | // mutable lambda
 90 |     template<class Ret, class Cls, class... Args>
 91 |     struct function_traits<Ret(Cls::*)(Args...)>
 92 |         : function_detail::types<Ret, Cls, std::true_type, std::true_type, Args...>
 93 |     {
 94 |     };
 95 | 
 96 | // immutable lambda
 97 |     template<class Ret, class Cls, class... Args>
 98 |     struct function_traits<Ret(Cls::*)(Args...) const>
 99 |         : function_detail::types<Ret, Cls, std::false_type, std::true_type, Args...>
100 |     {
101 |     };
102 | 
103 | // std::function
104 |     template<class Ret, class... Args>
105 |     struct function_traits<std::function<Ret(Args...)>>
106 |         : function_detail::types<Ret, std::nullptr_t, std::true_type, std::false_type, Args...>
107 |     {
108 |     };
109 | 
110 | // c-function
111 |     template<class Ret, class... Args>
112 |     struct function_traits<std::function<Ret(*)(Args...)>>
113 |         : function_detail::types<Ret, std::nullptr_t, std::true_type, std::false_type, Args...>
114 |     {
115 |     };
116 | }
117 | 


--------------------------------------------------------------------------------
/examples/hello_world.cpp:
--------------------------------------------------------------------------------
  1 | #include <cppcoro/task.hpp>
  2 | #include <cppcoro/on_scope_exit.hpp>
  3 | #include <cppcoro/cancellation_source.hpp>
  4 | #include <cppcoro/sync_wait.hpp>
  5 | #include <cppcoro/when_all.hpp>
  6 | #include <cppcoro/async_scope.hpp>
  7 | #include <cppcoro/http/http_server.hpp>
  8 | #include <cppcoro/http/route_controller.hpp>
  9 | #include <cppcoro/http/http_chunk_provider.hpp>
 10 | 
 11 | #include <fmt/printf.h>
 12 | 
 13 | #include <csignal>
 14 | #include <iostream>
 15 | #include <thread>
 16 | 
 17 | using namespace cppcoro;
 18 | namespace rng = std::ranges;
 19 | 
 20 | struct session
 21 | {
 22 |     int id = std::rand();
 23 | };
 24 | 
 25 | using add_controller_def = http::route_controller<
 26 |     R"(/add/(\d+)/(\d+))",  // route definition
 27 |     session,
 28 |     http::string_request,
 29 |     struct add_controller>;
 30 | 
 31 | struct add_controller : add_controller_def
 32 | {
 33 |     using add_controller_def::add_controller_def;
 34 | 
 35 |     auto on_get(int lhs, int rhs) -> task <http::string_response> {
 36 |         co_return http::string_response{http::status::HTTP_STATUS_OK,
 37 |                                         fmt::format("{}", lhs + rhs)};
 38 |     }
 39 | };
 40 | 
 41 | using hello_controller_def = http::route_controller<
 42 |     R"(/hello/(\w+))",  // route definition
 43 |     session,
 44 |     http::string_request,
 45 |     struct hello_controller>;
 46 | 
 47 | struct hello_controller : hello_controller_def
 48 | {
 49 |     using hello_controller_def::hello_controller_def;
 50 | 
 51 |     auto on_get(const std::string &who) -> task <http::string_response> {
 52 |         co_return http::string_response{http::status::HTTP_STATUS_OK,
 53 |                                         fmt::format("Hello {}", who)};
 54 |     }
 55 | };
 56 | 
 57 | using cat_controller_def = http::route_controller<
 58 |     R"(/cat)",  // route definition
 59 |     session,
 60 |     http::string_request,
 61 |     struct cat_controller>;
 62 | 
 63 | struct cat_controller : cat_controller_def
 64 | {
 65 |     using cat_controller_def::cat_controller_def;
 66 | 
 67 |     auto on_get() -> task <http::read_only_file_chunked_response> {
 68 |         co_return http::read_only_file_chunked_response{http::status::HTTP_STATUS_OK,
 69 |                                                         http::read_only_file_chunk_provider{service(), __FILE__}};
 70 |     }
 71 | };
 72 | 
 73 | using hello_server = http::controller_server<session,
 74 |     hello_controller,
 75 |     add_controller,
 76 |     cat_controller>;
 77 | 
 78 | std::optional<hello_server> g_server;
 79 | 
 80 | void at_exit(int) {
 81 |     fmt::print("exit requested\n");
 82 |     if (g_server) {
 83 |         fmt::print("stopping server\n");
 84 |         g_server->stop();
 85 |         fmt::print("done\n");
 86 |     }
 87 | }
 88 | 
 89 | int main(const int argc, const char **argv) {
 90 | 
 91 |     http::logging::log_level = spdlog::level::debug;
 92 | 
 93 |     using namespace cppcoro;
 94 | 
 95 |     std::vector<std::string_view> args{argv + 1, argv + argc};
 96 |     auto server_endpoint = net::ip_endpoint::from_string(args.empty() ? "127.0.0.1:4242" : args.at(0));
 97 |     fmt::print("listening at '{}'\n", server_endpoint->to_string());
 98 | 
 99 |     std::signal(SIGTERM, at_exit);
100 |     std::signal(SIGINT, at_exit);
101 | 
102 |     io_service service;
103 | 
104 | //#define SINGLE_THREAD
105 | #ifndef SINGLE_THREAD
106 |     static const constinit int thread_count = 5;
107 |     std::array<std::thread, thread_count> thread_pool;
108 |     rng::generate(thread_pool, [&] {
109 |         return std::thread([&] {
110 |             service.process_events();
111 |         });
112 |     });
113 | #endif
114 | 
115 |     auto do_serve = [&]() -> task<> {
116 |         auto _ = on_scope_exit([&] {
117 |             service.stop();
118 |         });
119 |         g_server.emplace(
120 |             service,
121 |             *server_endpoint);
122 |         co_await g_server->serve();
123 |     };
124 | 
125 |     (void) sync_wait(when_all(
126 |         do_serve()
127 | //#ifdef SINGLE_THREAD
128 |         , [&]() -> task<> {
129 |             service.process_events();
130 |             co_return;
131 |         }()
132 | //#endif
133 |         ));
134 | 
135 | #ifndef SINGLE_THREAD
136 |     rng::for_each(thread_pool, [](auto &&th) {
137 |         th.join();
138 |     });
139 | #endif
140 | 
141 |     std::cout << "Bye !\n";
142 |     return 0;
143 | }
144 | 


--------------------------------------------------------------------------------
/tests/test_chunked.cpp:
--------------------------------------------------------------------------------
  1 | #define CATCH_CONFIG_MAIN
  2 | 
  3 | #include <catch2/catch.hpp>
  4 | 
  5 | #include <fmt/format.h>
  6 | 
  7 | #include <cppcoro/http/http_server.hpp>
  8 | #include <cppcoro/http/http_client.hpp>
  9 | #include <cppcoro/http/http_chunk_provider.hpp>
 10 | #include <cppcoro/sync_wait.hpp>
 11 | #include <cppcoro/when_all.hpp>
 12 | #include <cppcoro/on_scope_exit.hpp>
 13 | #include <cppcoro/generator.hpp>
 14 | #include <cppcoro/read_only_file.hpp>
 15 | #include <cppcoro/write_only_file.hpp>
 16 | #include <cppcoro/http/route_controller.hpp>
 17 | 
 18 | using namespace cppcoro;
 19 | 
 20 | SCENARIO("chunked transfers should work", "[cppcoro-http][server][chunked]") {
 21 |     io_service ios;
 22 | 
 23 |     GIVEN("An chunk server") {
 24 | 
 25 |         struct session
 26 |         {
 27 |         };
 28 | 
 29 |         using test_reader_controller_def = http::route_controller<
 30 |             R"(/read)",  // route definition
 31 |             session,
 32 |             http::string_request,
 33 |             struct test_reader_controller>;
 34 | 
 35 |         struct test_reader_controller : test_reader_controller_def
 36 |         {
 37 |             using test_reader_controller_def::test_reader_controller_def;
 38 | 
 39 |             auto on_get() -> task <http::read_only_file_chunked_response> {
 40 |                 co_return http::read_only_file_chunked_response{http::status::HTTP_STATUS_OK,
 41 |                                                                 http::read_only_file_chunk_provider{service(), __FILE__}};
 42 |             }
 43 |         };
 44 |         static_assert(not http::detail::has_init_request_handler<test_reader_controller>);
 45 | 
 46 |         using test_writer_controller_def = http::route_controller<
 47 |             R"(/write/([\w\.]+))",  // route definition
 48 |             session,
 49 |             http::write_only_file_chunked_request,
 50 |             struct test_writer_controller>;
 51 | 
 52 |         struct test_writer_controller : test_writer_controller_def {
 53 |             using test_writer_controller_def::test_writer_controller_def;
 54 | 
 55 |             void init_request(std::string_view filename, http::write_only_file_chunked_request &request) {
 56 |                 request.body_access.init(filename);
 57 |             }
 58 | 
 59 |             task<http::string_response> on_post(std::string_view filename) {
 60 |                 co_return http::string_response{
 61 |                     http::status::HTTP_STATUS_OK,
 62 |                     fmt::format("successfully wrote {}", filename)
 63 |                 };
 64 |             }
 65 |         };
 66 |         static_assert(http::detail::has_init_request_handler<test_writer_controller>);
 67 | 
 68 |         using chunk_server = http::controller_server<session
 69 |             , test_reader_controller
 70 |             , test_writer_controller
 71 |             >;
 72 |         chunk_server server{ios, *net::ip_endpoint::from_string("127.0.0.1:4242")};
 73 | 
 74 |         WHEN("...") {
 75 |             http::client client{ios};
 76 |             sync_wait(when_all(
 77 |                 [&]() -> task<> {
 78 |                     auto _ = on_scope_exit([&] {
 79 |                         ios.stop();
 80 |                     });
 81 |                     co_await server.serve();
 82 |                 }(),
 83 |                 [&]() -> task<> {
 84 |                     auto _ = on_scope_exit([&] {
 85 |                         server.stop();
 86 |                     });
 87 |                     auto conn = co_await client.connect(*net::ip_endpoint::from_string("127.0.0.1:4242"));
 88 |                     auto f = read_only_file::open(ios, __FILE__);
 89 |                     std::string content;
 90 |                     content.resize(f.size());
 91 |                     auto[body, f_size] = co_await when_all(
 92 |                         [&]() -> task<std::string> {
 93 |                             auto response = co_await conn.get("/read");
 94 |                             REQUIRE(response->status == http::status::HTTP_STATUS_OK);
 95 |                             co_return std::string{co_await response->read_body()};
 96 |                         }(),
 97 |                         f.read(0, content.data(), content.size()));
 98 |                     REQUIRE(body == content);
 99 |                     auto response = co_await conn.post("/write/test.txt", std::move(body));
100 |                     REQUIRE(response->status == http::status::HTTP_STATUS_OK);
101 |                     auto f2 = read_only_file::open(ios, "test.txt");
102 |                     std::string content2;
103 |                     content2.resize(f2.size());
104 |                     co_await f2.read(0, content2.data(), content2.size());
105 |                     REQUIRE(content2 == content); // copied successful
106 |                     co_return;
107 |                 }(),
108 |                 [&]() -> task<> {
109 |                     ios.process_events();
110 |                     co_return;
111 |                 }())
112 |             );
113 |         }
114 |     }
115 | }
116 | 


--------------------------------------------------------------------------------
/include/cppcoro/http/details/router.hpp:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | 
  3 | #include <concepts>
  4 | #include <string>
  5 | #include <type_traits>
  6 | #include <typeinfo>
  7 | #include <typeindex>
  8 | #include <tuple>
  9 | #include <regex>
 10 | #include <variant>
 11 | 
 12 | #include <tuple>
 13 | 
 14 | #include <cppcoro/http/route_parameter.hpp>
 15 | 
 16 | #include <cppcoro/details/function_traits.hpp>
 17 | #include <cppcoro/details/type_index.hpp>
 18 | 
 19 | namespace cppcoro::http::detail {
 20 | 
 21 |     using namespace cppcoro::detail;
 22 | 
 23 |     template<typename ReturnT, typename PredicateType, typename FunctionTraitsT>
 24 |     struct view_handler_traits_impl : FunctionTraitsT
 25 |     {
 26 |         using parameters_tuple_type = typename FunctionTraitsT::template parameters_tuple<PredicateType>;
 27 |         using data_type = typename parameters_tuple_type::tuple_type;
 28 |         // TODO handle non-awaitables
 29 |         using await_result_type = std::conditional_t<std::is_void_v<typename FunctionTraitsT::return_type>, void, typename FunctionTraitsT::return_type::value_type>;
 30 |         static const constexpr size_t data_arity = std::tuple_size_v<data_type>;
 31 | 
 32 |         static constexpr auto make_tuple = parameters_tuple_type::make;
 33 | 
 34 |         template<int type_idx, int match_idx, typename MatcherT>
 35 |         static void _load_data(data_type &data, const MatcherT &match) {
 36 |             if constexpr (type_idx < data_arity) {
 37 |                 using ParamT = typename FunctionTraitsT::template arg<type_idx>::clean_type;
 38 |                 std::get<type_idx>(data) = route_parameter<ParamT>::load(match.template get<match_idx>());
 39 |                 _load_data<type_idx + 1, match_idx + route_parameter<ParamT>::group_count() + 1>(data, match);
 40 |             }
 41 |         }
 42 | 
 43 |         template<typename MatcherT>
 44 |         static bool load_data(const MatcherT &match, data_type &data) {
 45 |             _load_data<0, 1>(data, match);
 46 |             return true;
 47 |         }
 48 |     };
 49 | 
 50 |     template<int type_idx, int match_idx, int max, typename TupleT, typename MatcherT>
 51 |     static constexpr void _load_data(TupleT &data, const MatcherT &match) {
 52 |         if constexpr (type_idx < max) {
 53 |             using ParamT = std::decay_t<decltype(std::get<type_idx>(data))>;
 54 |             std::get<type_idx>(data) = route_parameter<ParamT>::load(match.template get<match_idx>());
 55 |             _load_data<type_idx + 1, match_idx + route_parameter<ParamT>::group_count() + 1, max>(data, match);
 56 |         }
 57 |     }
 58 | 
 59 |     template<typename TupleT, typename MatcherT>
 60 |     static constexpr bool load_data(const MatcherT &match, TupleT &data) {
 61 |         _load_data<0, 1, std::tuple_size_v<TupleT>>(data, match);
 62 |         return true;
 63 |     }
 64 | 
 65 |     template<int max_size, typename TupleT, typename MatcherT>
 66 |     static constexpr bool load_data(const MatcherT &match, TupleT &data) {
 67 |         _load_data<0, 1, max_size>(data, match);
 68 |         return true;
 69 |     }
 70 | 
 71 |     template<typename ReturnT, typename PredicateT, class T>
 72 |     struct view_handler_traits
 73 |         : view_handler_traits<ReturnT, PredicateT, decltype(&std::decay_t<T>::operator())>
 74 |     {
 75 |     };
 76 | 
 77 |     // mutable lambda
 78 |     template<typename ReturnT, typename PredicateT, class Ret, class Cls, class... Args>
 79 |     struct view_handler_traits<ReturnT, PredicateT, Ret(Cls::*)(Args...)>
 80 |         : view_handler_traits_impl<ReturnT, PredicateT, function_detail::types<Ret, Cls, std::true_type, std::true_type, Args...>>
 81 |     {
 82 |     };
 83 | 
 84 |     // immutable lambda
 85 |     template<typename ReturnT, typename PredicateT, class Ret, class Cls, class... Args>
 86 |     struct view_handler_traits<ReturnT, PredicateT, Ret(Cls::*)(Args...) const>
 87 |         : view_handler_traits_impl<ReturnT, PredicateT, function_detail::types<Ret, Cls, std::true_type, std::true_type, Args...>>
 88 |     {
 89 |     };
 90 | 
 91 |     // std::function
 92 |     template<typename ReturnT, typename PredicateT, class Ret, class... Args>
 93 |     struct view_handler_traits<ReturnT, PredicateT, std::function<Ret(Args...)>>
 94 |         : view_handler_traits_impl<ReturnT, PredicateT, function_detail::types<Ret, std::nullptr_t, std::true_type, std::true_type, Args...>>
 95 |     {
 96 |     };
 97 | 
 98 |     // c-function
 99 |     template<typename ReturnT, typename PredicateT, class Ret, class... Args>
100 |     struct view_handler_traits<ReturnT, PredicateT, Ret(*)(Args...)>
101 |         : view_handler_traits_impl<ReturnT, PredicateT, function_detail::types<Ret, std::nullptr_t, std::true_type, std::false_type, Args...>>
102 |     {
103 |     };
104 | 
105 | // helper type for the visitor #4
106 |     template<class... Ts>
107 |     struct overloaded : Ts ...
108 |     {
109 |         using Ts::operator()...;
110 |     };
111 | // explicit deduction guide (not needed as of C++20)
112 |     template<class... Ts> overloaded(Ts...) -> overloaded<Ts...>;
113 | 
114 | }  // namespace xdev::net::detail
115 | 


--------------------------------------------------------------------------------
/include/cppcoro/http/http_message.hpp:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * @file cppcoro/http/htt_message.hpp
  3 |  * @author Garcia Sylvain <garcia.6l20@gmail.com>
  4 |  */
  5 | #pragma once
  6 | 
  7 | #include <cppcoro/http/details/static_parser_handler.hpp>
  8 | 
  9 | #include <fmt/format.h>
 10 | 
 11 | namespace cppcoro::http {
 12 | 
 13 |     namespace detail {
 14 | 
 15 |         enum { max_body_size = 1024 };
 16 | 
 17 |         struct base_message
 18 |         {
 19 |             base_message() = default;
 20 | 
 21 |             explicit base_message(http::headers &&headers)
 22 |                 : headers{std::forward<http::headers>(headers)} {}
 23 | 
 24 |             base_message(base_message const &other) = delete;
 25 | 
 26 |             base_message &operator=(base_message const &other) = delete;
 27 | 
 28 |             base_message(base_message &&other) = default;
 29 | 
 30 |             base_message &operator=(base_message &&other) = default;
 31 | 
 32 |             http::headers headers;
 33 | 
 34 |             virtual bool is_chunked() = 0;
 35 |             virtual std::string build_header() = 0;
 36 |             virtual task<std::string_view> read_body(size_t max_size = max_body_size) = 0;
 37 |             virtual task<size_t> write_body(std::string_view data) = 0;
 38 |         };
 39 | 
 40 |         struct base_request : base_message
 41 |         {
 42 |             static constexpr bool is_request = true;
 43 |             static constexpr bool is_response = false;
 44 |             using base_message::base_message;
 45 | 
 46 |             base_request(base_request &&other) = default;
 47 |             base_request& operator=(base_request &&other) = default;
 48 | 
 49 |             base_request(http::method method, std::string &&path, http::headers &&headers = {})
 50 |                 : base_message{std::forward<http::headers>(headers)}, method{method},
 51 |                   path{std::forward<std::string>(path)} {}
 52 | 
 53 |             http::method method;
 54 |             std::string path;
 55 | 
 56 |             [[nodiscard]] auto method_str() const {
 57 |                 return http_method_str(static_cast<detail::http_method>(method));
 58 |             }
 59 | 
 60 |             std::string to_string() const {
 61 |                 return fmt::format("{} {}", method_str(), path);
 62 |             }
 63 |         };
 64 | 
 65 |         struct base_response : base_message
 66 |         {
 67 |             static constexpr bool is_response = true;
 68 |             static constexpr bool is_request = false;
 69 |             using base_message::base_message;
 70 | 
 71 |             base_response(base_response &&other) = default;
 72 |             base_response& operator=(base_response &&other) = default;
 73 | 
 74 |             base_response(http::status status, http::headers &&headers = {})
 75 |                 : base_message{std::forward<http::headers>(headers)}, status{status} {}
 76 | 
 77 |             http::status status;
 78 | 
 79 |             [[nodiscard]] auto status_str() const {
 80 |                 return http_status_str(static_cast<detail::http_status>(status));
 81 |             }
 82 | 
 83 |             std::string to_string() const {
 84 |                 return status_str();
 85 |             }
 86 |         };
 87 | 
 88 |         template<bool _is_response, is_body BodyT>
 89 |         struct abstract_message : std::conditional_t<_is_response, base_response, base_request>
 90 |         {
 91 |             using base_type = std::conditional_t<_is_response, base_response, base_request>;
 92 |             static constexpr bool is_response = _is_response;
 93 |             static constexpr bool is_request = !_is_response;
 94 | 
 95 |             using base_type::base_type;
 96 | 
 97 |             using body_type = BodyT;
 98 |             BodyT body_access;
 99 | 
100 |             std::optional<async_generator<std::string_view>> chunk_generator_;
101 |             std::optional<async_generator<std::string_view>::iterator> chunk_generator_it_;
102 | 
103 |             abstract_message(http::status status, BodyT &&body = {}, http::headers &&headers = {}) requires (is_response)
104 |                 : base_response{status, std::forward<http::headers>(headers)}
105 |                 , body_access{std::forward<BodyT>(body)} {
106 |             }
107 | 
108 |             abstract_message(http::method method, std::string &&path, BodyT &&body = {}, http::headers &&headers = {}) requires (is_request)
109 |                 : base_request{method, std::forward<std::string>(path), std::forward<http::headers>(headers)}
110 |                 , body_access{std::forward<BodyT>(body)} {
111 |             }
112 | 
113 | //            explicit abstract_message(base_type &&base) noexcept : base_type(std::move(base))  {}
114 | //            abstract_message& operator=(base_type &&base) noexcept {
115 | //                static_cast<base_type>(*this) = std::move(base);
116 | //            }
117 | 
118 |             bool is_chunked() final {
119 |                 if constexpr (ro_chunked_body<body_type> or wo_chunked_body<body_type>) {
120 |                     return true;
121 |                 } else {
122 |                     return false;
123 |                 }
124 |             }
125 | 
126 |             task<std::string_view> read_body(size_t max_size = max_body_size) final {
127 |                 if constexpr (ro_basic_body<BodyT>) {
128 |                     co_return std::string_view{body_access.data(), body_access.size()};
129 |                 } else if constexpr (ro_chunked_body<BodyT>) {
130 |                     if (not chunk_generator_) {
131 |                         chunk_generator_ = body_access.read(max_size);
132 |                         chunk_generator_it_ = co_await chunk_generator_->begin();
133 |                         if (*chunk_generator_it_ != chunk_generator_->end()) {
134 |                             co_return **chunk_generator_it_;
135 |                         }
136 |                     } else if (co_await ++*chunk_generator_it_ != chunk_generator_->end()) {
137 |                         co_return **chunk_generator_it_;
138 |                     }
139 |                     co_return std::string_view{};
140 |                 }
141 |             }
142 | 
143 |             task<size_t> write_body(std::string_view data) final {
144 |                 if constexpr (wo_basic_body<BodyT>) {
145 |                     auto size = data.size();
146 |                     this->body_access.append(data);
147 |                     co_return size;
148 |                 } else if constexpr (wo_chunked_body<BodyT>) {
149 |                     co_return co_await this->body_access.write(data);
150 |                 }
151 |             }
152 | 
153 |             inline std::string build_header() final {
154 |                 std::string output = _header_base();
155 |                 auto write_header = [&output](const std::string &field, const std::string &value) {
156 |                     output += fmt::format("{}: {}\r\n", field, value);
157 |                 };
158 |                 if constexpr (ro_basic_body<BodyT>) {
159 |                     this->headers["Content-Length"] = std::to_string(this->body_access.size());
160 |                 } else if constexpr (ro_chunked_body<BodyT>) {
161 |                     this->headers["Transfer-Encoding"] = "chunked";
162 |                 }
163 |                 for (auto &[field, value] : this->headers) {
164 |                     write_header(field, value);
165 |                 }
166 |                 output += "\r\n";
167 |                 return output;
168 |             }
169 | 
170 |         private:
171 |             inline auto _header_base() {
172 |                 if constexpr (is_response) {
173 |                     return fmt::format("HTTP/1.1 {} {}\r\n"
174 |                                        "UserAgent: cppcoro-http/0.0\r\n",
175 |                                        int(this->status),
176 |                                        http_status_str(this->status));
177 |                 } else {
178 |                     return fmt::format("{} {} HTTP/1.1\r\n"
179 |                                        "UserAgent: cppcoro-http/0.0\r\n",
180 |                                        this->method_str(),
181 |                                        this->path);
182 |                 }
183 |             }
184 |         };
185 | 
186 | 
187 |     }
188 | 
189 |     template<detail::is_body BodyT>
190 |     using abstract_response = detail::abstract_message<true, BodyT>;
191 | 
192 |     template<detail::is_body BodyT>
193 |     using abstract_request = detail::abstract_message<false, BodyT>;
194 | 
195 |     struct request_parser : detail::static_parser_handler<true> {
196 |         using detail::static_parser_handler<true>::static_parser_handler;
197 |     };
198 | 
199 |     struct response_parser : detail::static_parser_handler<false> {
200 |         using detail::static_parser_handler<false>::static_parser_handler;
201 |     };
202 | }


--------------------------------------------------------------------------------
/examples/simple_co_http_server/main.cpp:
--------------------------------------------------------------------------------
  1 | #include <cppcoro/http/route_controller.hpp>
  2 | #include <cppcoro/http/http_chunk_provider.hpp>
  3 | #include <cppcoro/sync_wait.hpp>
  4 | #include <cppcoro/when_all.hpp>
  5 | #include <cppcoro/on_scope_exit.hpp>
  6 | 
  7 | #include <lyra/cli_parser.hpp>
  8 | #include <lyra/opt.hpp>
  9 | #include <lyra/arg.hpp>
 10 | 
 11 | #include <thread>
 12 | #include <ranges>
 13 | 
 14 | using namespace cppcoro;
 15 | namespace fs = std::filesystem;
 16 | namespace rng = std::ranges;
 17 | 
 18 | struct session
 19 | {
 20 | 
 21 | };
 22 | 
 23 | using home_controller_def = http::route_controller<
 24 |     R"(/?([^\s]*)?)",
 25 |     session,
 26 |     http::string_request,
 27 |     struct home_controller>;
 28 | 
 29 | struct home_controller : home_controller_def
 30 | {
 31 |     using home_controller_def::home_controller_def;
 32 | 
 33 |     static constexpr std::string_view template_ = R"(
 34 | <!DOCTYPE html>
 35 | <html lang="en">
 36 | <head lang="en">
 37 | <meta charset="utf-8">
 38 | <meta name="viewport" content="width=device-width, initial-scale=1">
 39 | <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/5.0.0-alpha1/css/bootstrap.min.css" integrity="sha384-r4NyP46KrjDleawBgD5tp8Y7UzmLA05oM1iAEQ17CSuDqnUK2+k9luXQOfXJCJ4I" crossorigin="anonymous">
 40 | <title>{title}</title>
 41 | </head>
 42 | <body class="bg-light">
 43 |     <div class="container">
 44 |         <div class="py-5 text-center">
 45 |             <h2>Simple CppCoro HTTP Server</h2>
 46 |             <p class="lead">{path}</p>
 47 |         </div>
 48 |         <nav aria-label="breadcrumb">
 49 |         {breadcrumb}
 50 |         </nav>
 51 |         {body}
 52 |     </div>
 53 |     <script src="https://cdn.jsdelivr.net/npm/popper.js@1.16.0/dist/umd/popper.min.js" integrity="sha384-Q6E9RHvbIyZFJoft+2mJbHaEWldlvI9IOYy5n3zV9zzTtmI3UksdQRVvoxMfooAo" crossorigin="anonymous"></script>
 54 |     <script src="https://stackpath.bootstrapcdn.com/bootstrap/5.0.0-alpha1/js/bootstrap.min.js" integrity="sha384-oesi62hOLfzrys4LxRF63OJCXdXDipiYWBnvTl9Y9/TRlw5xlKIEHpNyvvDShgf/" crossorigin="anonymous"></script>
 55 | </body>
 56 | </html>
 57 | )";
 58 | 
 59 |     fmt::memory_buffer make_body(std::string_view path) {
 60 |         auto chrooted_path = (fs::relative(fs::path{path.data(), path.data() + path.size()})).string();
 61 |         if (chrooted_path.empty())
 62 |             chrooted_path = ".";
 63 |         fmt::print("-- get: {} ({})\n", path, chrooted_path);
 64 |         fmt::memory_buffer out;
 65 |         fmt::format_to(out, R"(<div class="list-group">)");
 66 |         for (auto &p: fs::directory_iterator(chrooted_path)) {
 67 |             fmt::format_to(out, R"(<a class="list-group-item-action" href="/{full_path}">{path}</a>)",
 68 |                            fmt::arg("path", fs::relative(p.path(), chrooted_path).c_str()),
 69 |                            fmt::arg("full_path", fs::relative(p.path()).c_str()));
 70 |         }
 71 |         fmt::format_to(out, "</div>");
 72 |         return out;
 73 |     }
 74 | 
 75 |     fmt::memory_buffer make_breadcrumb(std::string_view path) {
 76 |         fmt::memory_buffer buff;
 77 |         constexpr std::string_view init = R"(<nav aria-label="breadcrumb"><ol class="breadcrumb">)"
 78 |                                           R"(<li class="breadcrumb-item"><a href="/">Home</a></li>)";
 79 |         buff.append(std::begin(init), std::end(init));
 80 |         fs::path p = path;
 81 |         std::vector<std::string> elems = {
 82 |             {fmt::format(R"(<li class="breadcrumb-item active" aria-current="page"><a href="/{}">{}</a></li>)", p.string(), p.filename().c_str())}
 83 |         };
 84 |         p = p.parent_path();
 85 |         while (p.has_parent_path()) {
 86 |             elems.emplace_back(fmt::format(R"(<li class="breadcrumb-item"><a href="/{}">{}</a></li>)", p.string(), p.filename().c_str()));
 87 |             p = p.parent_path();
 88 |         }
 89 |         for (auto &elem : elems | std::views::reverse) {
 90 |             fmt::format_to(buff, "{}", elem);
 91 |         }
 92 |         return buff;
 93 |     }
 94 | 
 95 |     using response_type =
 96 |     std::variant<http::string_response, http::read_only_file_chunked_response>;
 97 |     static_assert(http::detail::is_visitable<response_type>);
 98 | 
 99 |     task<response_type> on_get(std::string_view path) {
100 |         auto status = http::status::HTTP_STATUS_OK;
101 |         auto chrooted_path = (fs::relative(fs::path{path.data(), path.data() + path.size()})).string();
102 |         if (chrooted_path.empty())
103 |             chrooted_path = ".";
104 |         spdlog::info("chrooted_path: {}\n", chrooted_path);
105 |         if (fs::is_directory(chrooted_path)) {
106 |             spdlog::info("get directory: {}\n", path);
107 |             fmt::memory_buffer body;
108 |             try {
109 |                 body = make_body(path);
110 |             } catch (fs::filesystem_error &error) {
111 |                 body = fmt::memory_buffer{};
112 |                 fmt::format_to(body, R"(<div><h6>Not found</h6><p>{}</p></div>)", error.what());
113 |                 status = http::status::HTTP_STATUS_NOT_FOUND;
114 |             }
115 |             auto breadcrumb = make_breadcrumb(path);
116 |             co_return http::string_response{
117 |                 status,
118 |                 fmt::format(template_,
119 |                             fmt::arg("title", path),
120 |                             fmt::arg("body", std::string_view{body.data(), body.size()}),
121 |                             fmt::arg("path", path),
122 |                             fmt::arg("breadcrumb", std::string_view{breadcrumb.data(), breadcrumb.size()})),
123 |                 http::headers{
124 |                     {"Content-Type", "text/html"}
125 |                 }
126 |             };
127 |         } else {
128 |             spdlog::info("get file: {}\n", path);
129 |             try {
130 |                 auto chrooted_path = (fs::relative(fs::path{path.data(), path.data() + path.size()})).string();
131 |                 co_return http::read_only_file_chunked_response{
132 |                     http::status::HTTP_STATUS_OK,
133 |                     http::read_only_file_chunk_provider{service(),
134 |                                                         chrooted_path}
135 |                 };
136 |             } catch (fs::filesystem_error &error) {
137 |                 spdlog::error("error {}", error.what());
138 |                 if (error.code() == std::errc::no_such_file_or_directory) {
139 |                     co_return http::string_response{
140 |                         http::status::HTTP_STATUS_NOT_FOUND,
141 |                         {error.what()}
142 |                     };
143 |                 } else {
144 |                     co_return http::string_response{
145 |                         http::status::HTTP_STATUS_INTERNAL_SERVER_ERROR,
146 |                         {error.what()}
147 |                     };
148 |                 }
149 |             }
150 |         }
151 |     }
152 | };
153 | 
154 | using simple_co_server = http::controller_server<session,
155 |     home_controller>;
156 | 
157 | 
158 | int main(int argc, char **argv) {
159 |     bool debug = false;
160 |     std::string endpoint_input = "127.0.0.1:4242";
161 |     uint32_t thread_count = std::thread::hardware_concurrency() - 1;
162 |     auto cli
163 |         = lyra::opt(debug)
164 |           ["-d"]["--debug"]
165 |               ("Enable debug output")
166 |           | lyra::opt(thread_count, "thread_count")
167 |           ["-t"]["--threads"]
168 |               ("Thread count")
169 |           | lyra::arg(endpoint_input, "endpoint")
170 |               ("Server endpoint");
171 |     auto result = cli.parse({argc, argv});
172 |     if (!result) {
173 |         std::cerr << "Error in command line: " << result.errorMessage() << std::endl;
174 |         exit(1);
175 |     }
176 | 
177 |     if (debug) {
178 |         spdlog::set_level(spdlog::level::debug);
179 |         http::logging::log_level = spdlog::level::debug;
180 |     }
181 | 
182 |     io_service service;
183 |     auto server_endpoint = net::ip_endpoint::from_string(endpoint_input);
184 | 
185 |     // TODO - fix multithreading
186 |     std::clamp(thread_count, 1u, 256u);
187 | 
188 |     spdlog::info("listening at '{}' on {} threads\n", server_endpoint->to_string(), thread_count + 1);
189 | 
190 |     std::vector<std::thread> tp{thread_count};
191 | 
192 |     rng::generate(tp, [&service] {
193 |         return std::thread{[&service]() mutable {
194 |             service.process_events();
195 |         }};
196 |     });
197 |     (void) sync_wait(when_all([&]() -> task<> {
198 |         auto _ = on_scope_exit([&] {
199 |             service.stop();
200 |         });
201 |         simple_co_server server{service, *server_endpoint};
202 |         co_await server.serve();
203 |     }(), [&]() -> task<> {
204 |         service.process_events();
205 |         co_return;
206 |     }()));
207 | 
208 |     rng::for_each(tp, [](auto &&thread) {
209 |         thread.join();
210 |     });
211 | }
212 | 


--------------------------------------------------------------------------------
/include/cppcoro/http/details/static_parser_handler.hpp:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | 
  3 | #include <cppcoro/http/http.hpp>
  4 | #include <cppcoro/task.hpp>
  5 | #include <cppcoro/async_generator.hpp>
  6 | 
  7 | #include <fmt/format.h>
  8 | 
  9 | #include <memory>
 10 | 
 11 | namespace cppcoro::http::detail {
 12 | 
 13 |     template<typename BodyT>
 14 |     concept ro_chunked_body = requires(BodyT &&body) {
 15 |         { body.read(size_t(0)) } -> std::same_as<async_generator<std::string_view>>;
 16 |     };
 17 |     template<typename BodyT>
 18 |     concept wo_chunked_body = requires(BodyT &&body) {
 19 |         { body.write(std::string_view{}) } -> std::same_as<task<size_t>>;
 20 |     };
 21 |     template<typename BodyT>
 22 |     concept rw_chunked_body = ro_chunked_body<BodyT> and wo_chunked_body<BodyT>;
 23 | 
 24 |     template<typename BodyT>
 25 |     concept ro_basic_body = requires(BodyT &&body) {
 26 |         { body.data() } -> std::same_as<char *>;
 27 |         { body.size() } -> std::same_as<size_t>;
 28 |     };
 29 |     template<typename BodyT>
 30 |     concept wo_basic_body = requires(BodyT &&body) {
 31 |         //{ BodyT((char *) nullptr, (char *) nullptr) } -> std::same_as<BodyT>;
 32 |         { body.append(std::string_view{}) };
 33 |     };
 34 |     template<typename BodyT>
 35 |     concept rw_basic_body = ro_basic_body<BodyT> and wo_basic_body<BodyT>;
 36 | 
 37 | 
 38 |     template<typename BodyT>
 39 |     concept readable_body = ro_basic_body<BodyT> or ro_chunked_body<BodyT>;
 40 | 
 41 |     template<typename BodyT>
 42 |     concept writeable_body = wo_basic_body<BodyT> or wo_chunked_body<BodyT>;
 43 | 
 44 |     template<typename BodyT>
 45 |     concept is_body = readable_body<BodyT> or writeable_body<BodyT>;
 46 | 
 47 |     template <bool is_request>
 48 |     class static_parser_handler {
 49 |         using self_type = static_parser_handler<is_request>;
 50 | 
 51 |     public:
 52 |         static_parser_handler() = default;
 53 |         static_parser_handler(static_parser_handler &&other) noexcept
 54 |             : parser_{std::move(other.parser_)}
 55 |             , header_field_{std::move(other.header_field_)}
 56 |             , state_{std::move(other.state_)} {
 57 |             if (parser_) {
 58 |                 parser_->data = this;
 59 |             }
 60 |         }
 61 |         static_parser_handler& operator=(static_parser_handler &&other) noexcept {
 62 |             parser_ = std::move(other.parser_);
 63 |             header_field_ = std::move(other.header_field_);
 64 |             state_ = std::move(other.state_);
 65 |             if (parser_) {
 66 |                 parser_->data = this;
 67 |             }
 68 |             return *this;
 69 |         }
 70 |         static_parser_handler(const static_parser_handler &) noexcept = delete;
 71 |         static_parser_handler& operator=(const static_parser_handler &) noexcept = delete;
 72 | 
 73 |         bool has_body() const noexcept {
 74 |             return body_.size();
 75 |         }
 76 | 
 77 |         operator bool() const {
 78 |             return state_ == status::on_message_complete;
 79 |         }
 80 | 
 81 |         const void parse(const char *data, size_t len) {
 82 |             body_ = {};
 83 |             const auto count = execute_parser(data, len);
 84 |             if (count < len) {
 85 |                 throw std::runtime_error{
 86 |                     std::string("parse error: ") + http_errno_description(detail::http_errno(parser_->http_errno))
 87 |                 };
 88 |             }
 89 | //            if (!parser_->upgrade &&
 90 | //                parser_->status != detail::s_message_done)
 91 | //                return false;
 92 |         }
 93 | 
 94 |         const void parse(std::string_view input) {
 95 |             parse(input.data(), input.size());
 96 |         }
 97 | 
 98 |         auto method() const {
 99 |             return static_cast<http::method>(parser_->method);
100 |         }
101 |         auto status_code() const {
102 |             return static_cast<http::status>(parser_->status_code);
103 |         }
104 | 
105 |         template <typename MessageT>
106 |         task<> load(MessageT &message) {
107 |             static_assert(is_request == MessageT::is_request);
108 |             if constexpr (is_request) {
109 |                 message.method = method();
110 |                 message.path = url_;
111 |             } else {
112 |                 message.status = status_code();
113 |             }
114 |             if (!this->body_.empty()) {
115 |                 co_await message.write_body(body_);
116 |             }
117 |         }
118 | 
119 |         const auto &url() const {
120 |             return url_;
121 |         }
122 | 
123 |         std::string to_string() const {
124 |             fmt::memory_buffer out;
125 |             std::string_view type;
126 |             if constexpr (is_request) {
127 |                 fmt::format_to(out, "request {} {}",
128 |                                detail::http_method_str(detail::http_method(parser_->method)),
129 |                                url_);
130 |             } else {
131 |                 fmt::format_to(out, "response {} ",
132 |                                detail::http_status_str(detail::http_status(parser_->status_code)));
133 |             }
134 |             fmt::format_to(out, "{}", body_);
135 |             return out.data();
136 |         }
137 | 
138 |     protected:
139 |         enum class status
140 |         {
141 |             none,
142 |             on_message_begin,
143 |             on_url,
144 |             on_status,
145 |             on_headers,
146 |             on_headers_complete,
147 |             on_body,
148 |             on_message_complete,
149 |             on_chunk_header,
150 |             on_chunk_header_compete,
151 |         };
152 | 
153 |         inline static auto &instance(detail::http_parser *parser) {
154 |             return *static_cast<self_type *>(parser->data);
155 |         }
156 | 
157 |         static inline int on_message_begin(detail::http_parser *parser)  {
158 |             auto &this_ = instance(parser);
159 |             this_.state_ = status::on_message_begin;
160 |             return 0;
161 |         }
162 | 
163 |         static inline int on_url(detail::http_parser *parser, const char *data, size_t len) {
164 |             auto &this_ = instance(parser);
165 |             this_.url_ = {data, data + len};
166 |             this_.state_ = status::on_url;
167 |             return 0;
168 |         }
169 | 
170 |         static inline int on_status(detail::http_parser *parser, const char *data, size_t len) {
171 |             auto &this_ = instance(parser);
172 |             this_.state_ = status::on_status;
173 |             return 0;
174 |         }
175 | 
176 |         static inline int on_header_field(detail::http_parser *parser, const char *data, size_t len) {
177 |             auto &this_ = instance(parser);
178 |             this_.state_ = status::on_headers;
179 |             this_.header_field_ = {data, len};
180 |             return 0;
181 |         }
182 | 
183 |         static inline int on_header_value(detail::http_parser *parser, const char *data, size_t len) {
184 |             auto &this_ = instance(parser);
185 | 
186 |             this_.state_ = status::on_headers;
187 |             this_.headers_[std::string{this_.header_field_}] = {data, data + len};
188 |             return 0;
189 |         }
190 | 
191 |         static inline int on_headers_complete(detail::http_parser *parser) {
192 |             auto &this_ = instance(parser);
193 |             this_.state_ = status::on_headers_complete;
194 |             return 0;
195 |         }
196 | 
197 |         static inline int on_body(detail::http_parser *parser, const char *data, size_t len) {
198 |             auto &this_ = instance(parser);
199 |             this_.body_ = {data, len};
200 |             this_.state_ = status::on_body;
201 |             return 0;
202 |         }
203 | 
204 |         static inline int on_message_complete(detail::http_parser *parser) {
205 |             auto &this_ = instance(parser);
206 |             this_.state_ = status::on_message_complete;
207 |             return 0;
208 |         }
209 | 
210 |         static inline int on_chunk_header(detail::http_parser *parser) {
211 |             auto &this_ = instance(parser);
212 |             this_.state_ = status::on_chunk_header;
213 |             return 0;
214 |         }
215 | 
216 |         static inline int on_chunk_complete(detail::http_parser *parser) {
217 |             auto &this_ = instance(parser);
218 |             this_.state_ = status::on_chunk_header_compete;
219 |             return 0;
220 |         }
221 | 
222 |         void init_parser() {
223 |             if (!parser_) {
224 |                 parser_ = std::make_unique<detail::http_parser>();
225 |                 if constexpr (is_request)
226 |                     http_parser_init(parser_.get(), detail::http_parser_type::HTTP_REQUEST);
227 |                 else http_parser_init(parser_.get(), detail::http_parser_type::HTTP_RESPONSE);
228 |                 parser_->data = this;
229 |             }
230 |         }
231 | 
232 |         auto execute_parser(const char *data, size_t len) {
233 |             init_parser();
234 |             return http_parser_execute(parser_.get(), &http_parser_settings_, data, len);
235 |         }
236 | 
237 |     private:
238 |         std::unique_ptr <detail::http_parser> parser_;
239 |         inline static detail::http_parser_settings http_parser_settings_ = {
240 |             on_message_begin,
241 |             on_url,
242 |             on_status,
243 |             on_header_field,
244 |             on_header_value,
245 |             on_headers_complete,
246 |             on_body,
247 |             on_message_complete,
248 |             on_chunk_header,
249 |             on_chunk_complete,
250 |         };
251 |         status state_{status::none};
252 |         std::string_view header_field_;
253 |         std::string url_;
254 |         std::string_view body_;
255 |         http::headers headers_;
256 |     };
257 | }


--------------------------------------------------------------------------------
/include/cppcoro/http/http_connection.hpp:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | 
  3 | #include <cppcoro/tcp/tcp.hpp>
  4 | #include <cppcoro/http/http.hpp>
  5 | #include <cppcoro/http/http_request.hpp>
  6 | #include <cppcoro/http/http_response.hpp>
  7 | #include <cppcoro/task.hpp>
  8 | #include <cppcoro/when_all.hpp>
  9 | 
 10 | #include <cppcoro/fmt/stringable.hpp>
 11 | 
 12 | #include <spdlog/spdlog.h>
 13 | #include <spdlog/sinks/stdout_color_sinks.h>
 14 | 
 15 | #include <charconv>
 16 | #include <cstring>
 17 | 
 18 | namespace cppcoro::http {
 19 | 
 20 |     class client;
 21 | 
 22 |     class server;
 23 | 
 24 |     template<typename ParentT, typename ResponseT = string_response, typename RequestT = string_request>
 25 |     class connection : public tcp::connection
 26 |     {
 27 |         std::shared_ptr<spdlog::logger> logger_ = [this]() mutable {
 28 |             auto logger = logging::get_logger(*this);
 29 |             logger->flush_on(spdlog::level::debug);
 30 |             return logger;
 31 |         }();
 32 |     public:
 33 |         auto &logger() {
 34 |             return *logger_;
 35 |         }
 36 | 
 37 |         std::string to_string() const {
 38 |             return fmt::format("connection::{}", peer_address());
 39 |         }
 40 | 
 41 |         static constexpr bool is_server() {
 42 |             if constexpr (std::is_same_v<ParentT, server>) {
 43 |                 return true;
 44 |             } else return false;
 45 |         }
 46 | 
 47 |         static constexpr bool is_client() {
 48 |             return not is_server();
 49 |         }
 50 | 
 51 |         using receive_type = std::conditional_t<is_client(), ResponseT, RequestT>;
 52 |         using base_receive_type = std::conditional_t<is_client(), http::detail::base_response, http::detail::base_request>;
 53 |         using send_type = std::conditional_t<is_client(), RequestT, ResponseT>;
 54 |         using base_send_type = std::conditional_t<is_client(), http::detail::base_request, http::detail::base_response>;
 55 |         using parser_type = std::conditional_t<is_client(), response_parser, request_parser>;
 56 | 
 57 |         connection(connection &&other) noexcept
 58 |             : tcp::connection{std::move(other)}, parent_{other.parent_}, /*input_{std::move(other.input_)},*/
 59 |               buffer_{std::move(other.buffer_)},
 60 |               logger_{std::move(other.logger_)} {
 61 |         }
 62 | 
 63 |         virtual ~connection() noexcept {
 64 |             if (logger_) {
 65 |                 logger_->info("connection closed");
 66 |                 logging::drop_logger(*this);
 67 |             }
 68 |         }
 69 | 
 70 |         connection(const connection &other) = delete;
 71 | 
 72 |         connection &operator=(connection &&other) = delete;
 73 | 
 74 |         connection &operator=(const connection &other) = delete;
 75 | 
 76 |         explicit connection(server &server, tcp::connection connection)
 77 |             : tcp::connection(std::move(connection)), parent_{server}, /*input_{std::make_unique<request>()},*/
 78 |               buffer_(2048, 0) {
 79 |             logger_->info("new sever connection");
 80 |         }
 81 | 
 82 |         explicit connection(client &client, tcp::connection connection)
 83 |             : tcp::connection(std::move(connection)), parent_{client}, /*input_{std::make_unique<response>()},*/
 84 |               buffer_(2048, 0) {
 85 |             logger_->info("new client connection");
 86 |         }
 87 | 
 88 |         task<receive_type *> next(std::function<base_receive_type &(const parser_type &)> init) {
 89 |             base_receive_type *result = nullptr;
 90 |             parser_type parser;
 91 |             auto init_result = [&] {
 92 |                 result = &init(parser);
 93 |                 if (!result) {
 94 |                     logger_->warn("unable to get valid message handler for {}", parser);
 95 |                 }
 96 |             };
 97 |             while (true) {
 98 |                 co_await parent_.service().schedule();
 99 |                 logger_->debug("waiting for incoming message...");
100 |                 //std::fill(begin(buffer_), end(buffer_), '\0');
101 |                 auto ret = co_await sock_.recv(buffer_.data(), buffer_.size(), ct_);
102 |                 logger_->debug("got something: {}", ret);
103 |                 bool done = ret <= 0;
104 |                 if (!done) {
105 |                     parser.parse(buffer_.data(), ret);
106 |                     if (!result) init_result();
107 |                     if (parser.has_body() && not parser) {
108 |                         // chunk
109 |                         if (result) {
110 |                             co_await parser.load(*result);
111 |                             logger_->debug("chunked message: {}", *result);
112 |                         } else {
113 |                             co_return nullptr;
114 |                         }
115 |                     }
116 |                     if (parser) {
117 |                         if (!result) init_result();
118 |                         if (result) {
119 |                             co_await parser.load(*result);
120 |                             logger_->debug("message: {}", *result);
121 |                             co_return std::move(static_cast<receive_type *>(result));
122 |                         } else {
123 |                             co_return nullptr;
124 |                         }
125 |                     }
126 |                 } else {
127 |                     co_return nullptr;
128 |                 }
129 |             }
130 |         }
131 | 
132 | 
133 |         auto post(std::string &&path, std::string &&data = "") requires(is_client()) {
134 |             return _send<http::method::post>(std::forward<std::string>(path), std::forward<std::string>(data));
135 |         }
136 | 
137 |         auto get(std::string &&path = "/", std::string &&data = "") requires(is_client()) {
138 |             return _send<http::method::get>(std::forward<std::string>(path), std::forward<std::string>(data));
139 |         }
140 | 
141 |         task<> send(std::derived_from<http::detail::base_message> auto &to_send) {
142 |             auto header = to_send.build_header();
143 |             try {
144 |                 if (to_send.is_chunked()) {
145 |                     std::string_view body;
146 |                     auto size = co_await sock_.send(header.data(), header.size(), ct_);
147 |                     assert(size == header.size());
148 |                     body = co_await to_send.read_body();
149 |                     while (!body.empty()) {
150 |                         auto size_str = fmt::format("{:x}\r\n", body.size());
151 |                         co_await sock_.send(size_str.data(), size_str.size(), ct_);
152 |                         logger_->debug("chunked body: {}", body);
153 |                         size = co_await sock_.send(body.data(), body.size(), ct_);
154 |                         if(size != body.size()) {
155 |                             logger_->error("body not sent ({}/{})", size, body.size());
156 |                         } else {
157 |                             co_await sock_.send("\r\n", 2, ct_);
158 |                         }
159 |                         body = co_await to_send.read_body();
160 |                     }
161 |                     auto size_str = fmt::format("{}\r\n\r\n", 0);
162 |                     co_await sock_.send(size_str.data(), size_str.size(), ct_);
163 | 
164 |                 } else {
165 |                     auto body = co_await to_send.read_body();
166 |                     auto size = co_await sock_.send(header.data(), header.size(), ct_);
167 |                     assert(size == header.size());
168 |                     if (!body.empty()) {
169 |                         logger_->debug("body: {}", body);
170 |                         auto size = co_await sock_.send(body.data(), body.size(), ct_);
171 |                         assert(size == body.size());
172 |                     }
173 |                 }
174 |             } catch (std::system_error &error) {
175 |                 if (error.code() == std::errc::connection_reset) {
176 |                     throw error; // Connection reset by peer
177 |                 }
178 |                 logger_->error("system_error caught: {}", error.what());
179 |                 if constexpr (is_server()) {
180 |                     string_response error_message {
181 |                         http::status::HTTP_STATUS_INTERNAL_SERVER_ERROR,
182 |                         std::string{error.what()},
183 |                         {}
184 |                     };
185 |                     if (error.code() == std::errc::no_such_file_or_directory) {
186 |                         error_message.status = http::status::HTTP_STATUS_NOT_FOUND;
187 |                     }
188 |                     header = error_message.build_header();
189 |                     auto size = co_await sock_.send(header.data(), header.size(), ct_);
190 |                     assert(size == header.size());
191 |                     auto body = co_await to_send.read_body();
192 |                     size = co_await sock_.send(body.data(), body.size(), ct_);
193 |                     assert(size == body.size());
194 |                 } else {
195 |                     throw;
196 |                 }
197 |             }
198 |         }
199 | 
200 |     private:
201 | 
202 | 
203 |         template<http::method _method>
204 |         task<std::optional<receive_type>> _send(std::string &&path, std::string &&data = "") requires(is_client()) {
205 |             send_type request{
206 |                 _method,
207 |                 std::forward<std::string>(path),
208 |                 std::forward<std::string>(data),
209 |                 {}
210 |             };
211 |             co_await send(request);
212 |             receive_type response{http::status::HTTP_STATUS_NOT_FOUND};
213 |             auto resp = co_await next([&](const http::response_parser &) -> receive_type & {
214 |                 return response;
215 |             });
216 |             if (resp) {
217 |                 co_return std::optional<receive_type>{std::move(*resp)};
218 |             }
219 |             co_return std::optional<receive_type>{};
220 |         }
221 | 
222 |         std::vector<char> buffer_;
223 |         ParentT &parent_;
224 |         // std::unique_ptr<receive_type> input_;
225 |     };
226 | }


--------------------------------------------------------------------------------
/include/cppcoro/http/route_controller.hpp:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * @file cppcoro/http/route_controller.hpp
  3 |  * @author Sylvain Garcia <garcia.6l20@gmail.com>
  4 |  */
  5 | #pragma once
  6 | 
  7 | #include <cppcoro/http/http_response.hpp>
  8 | #include <cppcoro/http/http_request.hpp>
  9 | #include <cppcoro/http/details/router.hpp>
 10 | #include <cppcoro/http/request_processor.hpp>
 11 | 
 12 | #include <cppcoro/task.hpp>
 13 | 
 14 | #include <ctll.hpp>
 15 | #include <ctre.hpp>
 16 | 
 17 | namespace cppcoro::http {
 18 | 
 19 |     namespace detail {
 20 | 
 21 | #define __CPPCORO_HTTP_MAKE_METHOD_CHECKER(__method) \
 22 |         template <typename ControllerT> \
 23 |         concept is_ ## __method ## _controller = requires (ControllerT controller) { \
 24 |             &ControllerT::on_ ## __method; \
 25 |         };
 26 | 
 27 |         __CPPCORO_HTTP_MAKE_METHOD_CHECKER(post)
 28 |         __CPPCORO_HTTP_MAKE_METHOD_CHECKER(get)
 29 |         __CPPCORO_HTTP_MAKE_METHOD_CHECKER(put)
 30 |         __CPPCORO_HTTP_MAKE_METHOD_CHECKER(del)
 31 |         __CPPCORO_HTTP_MAKE_METHOD_CHECKER(head)
 32 |         __CPPCORO_HTTP_MAKE_METHOD_CHECKER(options)
 33 |         __CPPCORO_HTTP_MAKE_METHOD_CHECKER(patch)
 34 | #undef __CPPCORO_HTTP_MAKE_METHOD_CHECKER
 35 | 
 36 |         template <typename ControllerT>
 37 |         concept has_init_request_handler = requires() {
 38 |             &ControllerT::init_request;
 39 |         };
 40 | 
 41 |         struct abstract_route_controller
 42 |         {
 43 |             explicit abstract_route_controller(io_service &service) noexcept : service_{service} {}
 44 |             virtual ~abstract_route_controller() = default;
 45 | 
 46 |             virtual task<detail::base_response&> process() = 0;
 47 |             virtual http::detail::base_request *_init_request(std::string_view url) = 0;
 48 |             virtual bool match(std::string_view url) = 0;
 49 | 
 50 |             io_service &service_;
 51 |             void *session_ = nullptr;
 52 |         };
 53 | 
 54 |     }
 55 | 
 56 |     namespace detail {
 57 | 
 58 |         template <typename T>
 59 |         concept is_visitable = requires (T &&v) {
 60 |             { std::get<0>(v) };
 61 |         };
 62 | 
 63 |         template <typename T>
 64 |         concept has_body_type = requires (T &&v) {
 65 |             typename T::body_type;
 66 |         };
 67 |     }
 68 | 
 69 |     template<ctll::fixed_string route, typename SessionT, typename RequestT, typename Derived>
 70 |     class route_controller : public detail::abstract_route_controller
 71 |     {
 72 |         using request_type = RequestT;
 73 |         using builder_type = ctre::regex_builder<route>;
 74 |         static constexpr inline auto match_ = ctre::regex_match_t<typename builder_type::type>();
 75 |         std::invoke_result_t<decltype(match_), std::string_view> match_result_;
 76 | 
 77 |         std::optional<request_type> request_;
 78 | 
 79 |         auto &self() {
 80 |             return static_cast<Derived&>(*this);
 81 |         }
 82 | 
 83 |         using handler_type = std::function<cppcoro::task<detail::base_response&>(route_controller&)>;
 84 |         std::map<http::method, handler_type> handlers_;
 85 |         http::string_response error_response_;
 86 | 
 87 | 
 88 |         template<http::method method, typename HandlerT>
 89 |         void register_handler(HandlerT &&handler) {
 90 |             using traits = detail::function_traits<HandlerT>;
 91 |             using handler_trait = detail::view_handler_traits<cppcoro::task<detail::base_response>,
 92 |                 detail::function_detail::parameters_tuple_all_enabled,
 93 |                 HandlerT>;
 94 |             using response_type = typename handler_trait::await_result_type;
 95 |             std::shared_ptr<response_type> response;
 96 |             constexpr auto has_response_body = detail::has_body_type<response_type>;
 97 |             if constexpr (has_response_body) {
 98 |                 if constexpr (std::constructible_from<typename response_type::body_type, io_service&>) {
 99 |                     response = std::make_shared<response_type>(
100 |                         http::status::HTTP_STATUS_INTERNAL_SERVER_ERROR,
101 |                         typename response_type::body_type{service_});
102 |                 } else {
103 |                     response = std::make_shared<response_type>();
104 |                 }
105 |             } else {
106 |                 response = std::make_shared<response_type>();
107 |             }
108 |             handlers_[method] = [data = std::make_shared<typename handler_trait::data_type>(),
109 |                                  response = response,
110 |                                  handler = std::forward<HandlerT>(handler)]
111 |                 (route_controller &self) mutable -> cppcoro::task<detail::base_response&> {
112 |                 handler_trait::load_data(self.match_result_, *data);
113 |                 *response = co_await std::apply(handler, std::tuple_cat(std::make_tuple(&self.self()), *data));
114 |                 if constexpr (detail::is_visitable<response_type>) {
115 |                     detail::base_response *ptr = nullptr;
116 |                     std::visit([&ptr](auto &elem) mutable {
117 |                         ptr = &elem;
118 |                     }, *response);
119 |                     co_return *ptr;
120 |                 } else {
121 |                     co_return *response;
122 |                 }
123 |             };
124 |         };
125 | 
126 |         bool match(std::string_view url) final {
127 |             match_result_ = std::move(match_(url));
128 |             return bool(match_result_);
129 |         }
130 | 
131 |         http::detail::base_request *_init_request(std::string_view url) final {
132 |             request_.emplace(make_request());
133 |             request_->path = url;
134 |             assert(match(request_->path)); // reload results
135 |             if constexpr (detail::has_init_request_handler<Derived>) {
136 |                 using traits = detail::function_traits<decltype(&Derived::init_request)>;
137 |                 using data_type = typename traits::template parameters_tuple<detail::function_detail::parameters_tuple_disable<request_type>>::tuple_type;
138 |                 data_type data;
139 |                 detail::load_data(match_result_, data);
140 |                 std::apply(&Derived::init_request, std::tuple_cat(
141 |                     std::make_tuple(static_cast<Derived *>(this)),
142 |                     data,
143 |                     std::tuple<request_type&>(*request_)));
144 |             }
145 |             return &*request_;
146 |         }
147 | 
148 |         auto make_request() {
149 |             using request_body = typename request_type::body_type;
150 |             if constexpr (std::constructible_from<request_body, io_service&>) {
151 |                 return request_type{http::method::unknown, "", request_body{service_}};
152 |             } else {
153 |                 return request_type{http::method::unknown, "", request_body{}};
154 |             }
155 |         }
156 | 
157 | 
158 |     protected:
159 | 
160 |         auto &request() { return *request_; }
161 |         auto &session() { return *static_cast<SessionT*>(session_); }
162 |         auto &service() { return service_; }
163 | 
164 |     public:
165 |         route_controller(const route_controller&) = delete;
166 |         route_controller& operator=(const route_controller&) = delete;
167 |         route_controller(route_controller &&other) = default;
168 |         route_controller& operator=(route_controller &&other) noexcept = default;
169 | 
170 |         explicit route_controller(io_service &service)
171 |             : detail::abstract_route_controller{service} {
172 | 
173 | #define __CPPCORO_HTTP_MAKE_METHOD_CHECKER_IMPL(__method) \
174 |             if constexpr (detail::is_ ## __method ## _controller<Derived>) { \
175 |                 register_handler<http::method:: __method>(&Derived::on_ ## __method);\
176 |             }
177 |             __CPPCORO_HTTP_MAKE_METHOD_CHECKER_IMPL(post)
178 |             __CPPCORO_HTTP_MAKE_METHOD_CHECKER_IMPL(get)
179 |             __CPPCORO_HTTP_MAKE_METHOD_CHECKER_IMPL(put)
180 |             __CPPCORO_HTTP_MAKE_METHOD_CHECKER_IMPL(del)
181 |             __CPPCORO_HTTP_MAKE_METHOD_CHECKER_IMPL(head)
182 |             __CPPCORO_HTTP_MAKE_METHOD_CHECKER_IMPL(options)
183 |             __CPPCORO_HTTP_MAKE_METHOD_CHECKER_IMPL(patch)
184 | #undef __CPPCORO_HTTP_MAKE_METHOD_CHECKER_IMPL
185 |         }
186 | 
187 |         task<detail::base_response&> process() override {
188 |             if (handlers_.contains(request_->method)) {
189 |                 auto &result = co_await handlers_.at(request_->method)(*this);
190 |                 co_return result;
191 |             }
192 |             error_response_.status = http::status::HTTP_STATUS_METHOD_NOT_ALLOWED;
193 |             co_return error_response_;
194 |         }
195 |     };
196 | 
197 |     template<typename SessionType, typename...ControllersT>
198 |     struct controller_server : http::request_processor<SessionType, controller_server<SessionType, ControllersT...>>
199 |     {
200 |         using processor_type = http::request_processor<SessionType, controller_server<SessionType, ControllersT...>>;
201 |         using session_type = SessionType;
202 | 
203 |         controller_server(io_service &service, const net::ip_endpoint &endpoint) noexcept
204 |             : processor_type{service, endpoint}
205 |             , controllers_{std::make_unique<ControllersT>(ControllersT{this->ios_})...}
206 |         {
207 |         }
208 | 
209 |         http::detail::base_request *prepare(const http::request_parser &parser, session_type &session) {
210 |             next_proc_ = nullptr;
211 |             for (auto &controller : controllers_) {
212 |                 if (controller->match(parser.url())) {
213 |                     controller->session_ = &session;
214 |                     next_proc_ = controller.get();
215 |                     return controller->_init_request(parser.url());
216 |                 }
217 |             }
218 |             return nullptr;
219 |         }
220 | 
221 |         cppcoro::task<http::detail::base_response&> process(http::detail::base_request &request) {
222 |             if (!next_proc_) {
223 |                 error_response_ = string_response{
224 |                     http::status::HTTP_STATUS_NOT_FOUND,
225 |                 };
226 |                 co_return error_response_;
227 |             } else {
228 |                 http::detail::base_response &response = co_await next_proc_->process();
229 |                 co_return response;
230 |             }
231 |         }
232 | 
233 |     private:
234 |         string_response error_response_;
235 |         detail::abstract_route_controller *next_proc_;
236 |         std::array<std::unique_ptr<detail::abstract_route_controller>, sizeof...(ControllersT)> controllers_;
237 |     };
238 | }
239 | 


--------------------------------------------------------------------------------