Example of coroutines with boost (#474)

* Example of coroutines with boost

Thanks for your videos
Just wanted to share my approach of using boost asio with coroutines
Coroutines are stackfull and also from boost (there are also stackless from cpp-20 - the channel "Talking Async" on youtube  shows examples of use)
No idea how it affects performance, but it is more readable (at least for me) and does not use explicit shared pointers(which do worsen performance)

* adding threads

vector of threads calling ioc.run()

Author: grincha09

lessons/263/app-cpp/src/main.cpp

@@ -1,42 +1,135 @@
-#include <algorithm>
 #include <boost/beast/core.hpp>
 #include <boost/beast/http.hpp>
-#include <cstdlib>
-#include <iostream>
-#include <memory>
-#include <thread>
-#include <vector>
+#include <boost/asio/spawn.hpp> // need to link with boost_coroutine
 
-#include "listener.hpp"
-#include "spdlog/spdlog.h"
+#include <boost/json.hpp>
+#include <boost/json/src.hpp>
 
+#include <thread>
 
 namespace beast = boost::beast;
 namespace http = beast::http;
 namespace net = boost::asio;
-using tcp = asio::ip::tcp;
+using tcp = net::ip::tcp;
 
+namespace json = boost::json;
+
+void fail(beast::error_code const &ec, const char* const what) {
+    fprintf(stderr, "error: %s, %s\n", what, ec.message().c_str());
+}
 
 int main() {
-    auto const address = net::ip::make_address("0.0.0.0");
-    constexpr auto port = static_cast<unsigned short>(8080);
-    // 2 Threads, same as Rust
-    constexpr auto threads = 2;
+    beast::error_code ec;
+    net::io_context ioc;
+
+    tcp::endpoint endpoint(tcp::v4(), 8080);
+
+    tcp::acceptor acceptor(ioc);
+    acceptor.open(endpoint.protocol(), ec);
+    if (ec) {
+        fail(ec, "open");
+        return 1;
+    }
+
+    acceptor.set_option(net::socket_base::reuse_address(true), ec);
+    if (ec) {
+        fail(ec, "set_option");
+        return 1;
+    }
+
+    acceptor.bind(endpoint, ec);
+    if (ec) {
+        fail(ec, "bind");
+        return 1;
+    }
+
+    acceptor.listen(net::socket_base::max_listen_connections, ec);
+    if (ec) {
+        fail(ec, "listen");
+        return 1;
+    }
 
-    // The io_context is required for all I/O
-    net::io_context ioc{threads};
+    net::spawn(acceptor.get_executor(), [&](net::yield_context const &yield) {
+        while (acceptor.is_open()) {
+            tcp::socket socket(ioc);
+            acceptor.async_accept(socket, yield[ec]);
+            if (ec) {
+                fail(ec, "accept");
+                break;
+            }
 
-    // Create and launch a listening port
-    std::make_shared<listener>(ioc, tcp::endpoint{address, port})->run();
+            net::spawn(acceptor.get_executor(), [s = std::move(socket)](net::yield_context const &yield) mutable {
+                beast::tcp_stream stream(std::move(s));
+
+                beast::error_code ec;
+                beast::flat_buffer buffer;
+                while (true) { // TODO not sure how keep_alive should work
+                    http::request_parser<http::string_body> requestParser;
+                    http::async_read(stream, buffer, requestParser, yield[ec]);
+                    if (ec) {
+                        fail(ec, "read");
+                        return;
+                    }
+
+                    auto const &request = requestParser.get();
+
+                    http::response<http::dynamic_body> response;
+                    response.version(request.version());
+                    response.keep_alive(request.keep_alive());
+
+                    if (request.method() == http::verb::get && request.target() == "/api/v3/ticker/bookTicker") {
+                        response.result(http::status::ok);
+                        response.set(http::field::content_type, "application/json");
+                        // TODO without the vector for simplicity of that example
+                        beast::ostream(response.body()) << json::serialize(json::array{
+                                json::object{
+                                        {"symbol",   "LTCBTC"},
+                                        {"bidPrice", "4.00000000"},
+                                        {"bidQty",   "431.00000000"},
+                                        {"askPrice", "4.00000200"},
+                                        {"askQty",   "9.00000000"}
+                                },
+                                json::object{
+                                        {"symbol",   "ETHBTC"},
+                                        {"bidPrice", "0.07946700"},
+                                        {"bidQty",   "49.00000000"},
+                                        {"askPrice", "100000.00000000"},
+                                        {"askQty",   "1000.00000000"}
+                                },
+                        });
+                    } else {
+                        response.result(http::status::not_found);
+                        response.set(http::field::content_type, "text/plain");
+                        beast::ostream(response.body()) << "Not Found";
+                    }
+
+                    response.prepare_payload();
+
+                    http::async_write(stream, response, yield[ec]);
+                    if (ec) {
+                        fail(ec, "write");
+                        return;
+                    }
+
+                    // TODO not sure how keep_alive should work
+//                    printf("%d\n", request.keep_alive()); // always return true (through curl)
+                                                          // from docs: The value depends on the *version* in the message
+                    auto const con_header = request.find("Connection");
+                    if (con_header == request.end() || con_header->value() != "keep-alive")
+                        break;
+                }
+            });
+        }
+    });
+
+    constexpr auto threads = 2;
 
-    // Run the I/O service on the requested number of threads
     std::vector<std::thread> v;
     v.reserve(threads - 1);
     for (auto i = threads - 1; i > 0; --i)
         v.emplace_back([&ioc] { ioc.run(); });
 
-    spdlog::info("Starting a server on port: {}", port);
     ioc.run();
 
-    return EXIT_SUCCESS;
+    return 0;
 }