async_server.hpp

Go to the documentation of this file.

// Copyright (c) 2021 MIT Digital Currency Initiative,
//                    Federal Reserve Bank of Boston
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
#ifndef OPENCBDC_TX_SRC_RPC_ASYNC_SERVER_H_
#define OPENCBDC_TX_SRC_RPC_ASYNC_SERVER_H_
 
#include "server.hpp"
 
namespace cbdc::rpc {
    template<typename Request,
             typename Response,
             typename InBuffer = buffer,
             typename OutBuffer = buffer>
    class async_server
        : public server<Request, Response, InBuffer, OutBuffer> {
      public:
        async_server() = default;
        async_server(async_server&&) noexcept = default;
        auto operator=(async_server&&) noexcept -> async_server& = default;
        async_server(const async_server&) = default;
        auto operator=(const async_server&) -> async_server& = default;
 
        ~async_server() override = default;
 
        static constexpr handler_type handler = handler_type::async;
 
        using response_callback_type
            = std::function<void(std::optional<Response>)>;
 
        using callback_type
            = std::function<bool(Request, response_callback_type)>;
 
        void register_handler_callback(callback_type callback) {
            m_callback = std::move(callback);
        }
 
      protected:
        auto async_call(InBuffer request_buf,
                        std::function<void(cbdc::buffer)> response_callback)
            -> std::optional<OutBuffer> {
            if constexpr(!raw_mode) {
                auto req = server_type::deserialize_request(request_buf);
                if(!req.has_value()) {
                    return std::nullopt;
                }
                auto success = m_callback(
                    std::move(req.value().m_payload),
                    [&,
                     resp_cb = std::move(response_callback),
                     hdr
                     = req.value().m_header](std::optional<Response> resp) {
                        auto resp_buf
                            = server_type::serialize_response(std::move(hdr),
                                                              std::move(resp));
                        resp_cb(std::move(resp_buf));
                    });
                if(!success) {
                    return server_type::template serialize_response<Response>(
                        std::move(req.value().m_header),
                        std::nullopt);
                }
            } else {
                auto maybe_failure
                    = server_type::make_failure_response(request_buf);
                if(!maybe_failure.has_value()) {
                    return std::nullopt;
                }
                auto success
                    = m_callback(std::move(request_buf),
                                 [&,
                                  resp_cb = std::move(response_callback),
                                  fail_buf = maybe_failure.value()](
                                     std::optional<Response> resp) {
                                     if(resp.has_value()) {
                                         resp_cb(std::move(resp.value()));
                                     } else {
                                         resp_cb(std::move(fail_buf));
                                     }
                                 });
                if(!success) {
                    return maybe_failure;
                }
            }
            return std::nullopt;
        }
 
      private:
        callback_type m_callback;
 
        using server_type = server<Request, Response, InBuffer, OutBuffer>;
 
        static constexpr auto raw_mode
            = std::is_same_v<Request,
                             buffer> && std::is_same_v<Response, buffer>;
    };
 
    using raw_async_server = async_server<buffer, buffer>;
}
 
#endif