ARCHIVE/clio
1
0
Fork 0
mirror of https://github.com/XRPLF/clio.git synced 2025-11-04 20:05:51 +00:00
Code Issues Packages Projects Releases Wiki Activity

Tx Subs Rebase Fix (#23)

Browse Source 
Subscription fixes
This commit is contained in:
Nathan Nichols
2021-05-26 09:53:54 -07:00
committed by GitHub
parent 1de29d3a44
commit 4340497857
11 changed files with 515 additions and 407 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
CMakeLists.txt
View File

@@ -62,6 +62,8 @@ target_sources(reporting PRIVATE
reporting/Pg.cpp
reporting/DBHelpers.cpp
reporting/ReportingETL.cpp
reporting/server/session.cpp
reporting/server/SubscriptionManager.cpp
handlers/AccountInfo.cpp
handlers/Tx.cpp
handlers/RPCHelpers.cpp
@@ -75,9 +77,10 @@ target_sources(reporting PRIVATE
handlers/AccountLines.cpp
handlers/AccountCurrencies.cpp
handlers/AccountOffers.cpp
handlers/AccountObjects.cpp)
handlers/AccountObjects.cpp
handlers/ChannelAuthorize.cpp
handlers/ChannelVerify.cpp)
handlers/ChannelVerify.cpp
handlers/Subscribe.cpp)
message(${Boost_LIBRARIES})

22
handlers/RPCHelpers.cpp
View File

@@ -81,6 +81,28 @@ getJson(ripple::STBase const& obj)
return value.as_object();
}
boost::json::object
getJson(ripple::TxMeta const& meta)
{
auto start = std::chrono::system_clock::now();
boost::json::value value = boost::json::parse(
meta.getJson(ripple::JsonOptions::none).toStyledString());
auto end = std::chrono::system_clock::now();
value.as_object()["deserialization_time_microseconds"] =
std::chrono::duration_cast<std::chrono::microseconds>(end - start)
.count();
return value.as_object();
}
boost::json::value
getJson(Json::Value const& value)
{
boost::json::value boostValue =
boost::json::parse(value.toStyledString());
return boostValue;
}
boost::json::object
getJson(ripple::SLE const& sle)
{

11
handlers/RPCHelpers.h
View File

@@ -15,12 +15,23 @@ std::pair<
std::shared_ptr<ripple::STObject const>>
deserializeTxPlusMeta(Backend::TransactionAndMetadata const& blobs);
std::pair<
std::shared_ptr<ripple::STTx const>,
std::shared_ptr<ripple::TxMeta const>>
deserializeTxPlusMeta(Backend::TransactionAndMetadata const& blobs, std::uint32_t seq);
boost::json::object
getJson(ripple::STBase const& obj);
boost::json::object
getJson(ripple::SLE const& sle);
boost::json::object
getJson(ripple::TxMeta const& meta);
boost::json::value
getJson(Json::Value const& value);
std::optional<uint32_t>
ledgerSequenceFromRequest(
boost::json::object const& request,

72
reporting/ReportingETL.cpp
View File

@@ -138,13 +138,63 @@ ReportingETL::loadInitialLedger(uint32_t startingSequence)
return lgrInfo;
}
std::optional<ripple::Fees>
ReportingETL::getFees(std::uint32_t seq)
{
ripple::Fees fees;
auto key = ripple::keylet::fees().key;
auto bytes = flatMapBackend_->fetchLedgerObject(key, seq);
if (!bytes)
{
BOOST_LOG_TRIVIAL(error) << __func__ << " - could not find fees";
return {};
}
ripple::SerialIter it(bytes->data(), bytes->size());
ripple::SLE sle{it, key};
if (sle.getFieldIndex(ripple::sfBaseFee) != -1)
fees.base = sle.getFieldU64(ripple::sfBaseFee);
if (sle.getFieldIndex(ripple::sfReferenceFeeUnits) != -1)
fees.units = sle.getFieldU32(ripple::sfReferenceFeeUnits);
if (sle.getFieldIndex(ripple::sfReserveBase) != -1)
fees.reserve = sle.getFieldU32(ripple::sfReserveBase);
if (sle.getFieldIndex(ripple::sfReserveIncrement) != -1)
fees.increment = sle.getFieldU32(ripple::sfReserveIncrement);
return fees;
}
void
ReportingETL::publishLedger(ripple::LedgerInfo const& lgrInfo)
{
// app_.getOPs().pubLedger(ledger);
auto ledgerRange = flatMapBackend_->fetchLedgerRange();
auto fees = getFees(lgrInfo.seq);
auto transactions =
flatMapBackend_->fetchAllTransactionsInLedger(lgrInfo.seq);
if (!fees || !ledgerRange)
{
BOOST_LOG_TRIVIAL(error) << __func__
<< " - could not fetch from database";
return;
}
std::string range = std::to_string(ledgerRange->minSequence) + "-" + std::to_string(ledgerRange->maxSequence);
subscriptions_->pubLedger(lgrInfo, *fees, range, transactions.size());
for (auto& txAndMeta : transactions)
subscriptions_->pubTransaction(txAndMeta, lgrInfo.seq);
setLastPublish();
}
bool
ReportingETL::publishLedger(uint32_t ledgerSequence, uint32_t maxAttempts)
{
@@ -196,15 +246,16 @@ ReportingETL::publishLedger(uint32_t ledgerSequence, uint32_t maxAttempts)
continue;
}
/*
publishStrand_.post([this, ledger]() {
app_.getOPs().pubLedger(ledger);
setLastPublish();
BOOST_LOG_TRIVIAL(info)
<< __func__ << " : "
<< "Published ledger. " << detail::toString(ledger->info());
});
*/
// publishStrand_.post([this, &ledger, &fees]() {
// subs_->pubLedger(*ledger, *fees);
// setLastPublish();
// BOOST_LOG_TRIVIAL(info)
// << __func__ << " : "
// << "Published ledger. " << ledger->seq;
// });
publishLedger(ledger);
return true;
}
return false;
@@ -707,6 +758,7 @@ ReportingETL::ReportingETL(
: publishStrand_(ioc)
, ioContext_(ioc)
, flatMapBackend_(Backend::makeBackend(config))
, subscriptions_(std::make_unique<SubscriptionManager>())
, loadBalancer_(
config.at("etl_sources").as_array(),
*flatMapBackend_,

16
reporting/ReportingETL.h
View File

@@ -28,6 +28,7 @@
#include <reporting/BackendInterface.h>
#include <reporting/ETLHelpers.h>
#include <reporting/ETLSource.h>
#include <reporting/server/SubscriptionManager.h>
#include <reporting/Pg.h>
#include "org/xrpl/rpc/v1/xrp_ledger.grpc.pb.h"
@@ -40,6 +41,7 @@
#include <chrono>
struct AccountTransactionsData;
class SubscriptionManager;
/**
* This class is responsible for continuously extracting data from a
@@ -60,9 +62,11 @@ class ReportingETL
{
private:
std::unique_ptr<BackendInterface> flatMapBackend_;
std::unique_ptr<SubscriptionManager> subscriptions_;
std::optional<uint32_t> onlineDeleteInterval_;
uint32_t extractorThreads_ = 1;
std::thread worker_;
boost::asio::io_context& ioContext_;
@@ -247,6 +251,12 @@ private:
void
publishLedger(ripple::LedgerInfo const& lgrInfo);
/// Get fees at a current ledger_index
/// @param seq the ledger index
/// @return nullopt if not found, fees if found.
std::optional<ripple::Fees>
getFees(std::uint32_t seq);
public:
ReportingETL(
boost::json::object const& config,
@@ -336,6 +346,12 @@ public:
return *flatMapBackend_;
}
SubscriptionManager&
getSubscriptionManager()
{
return *subscriptions_;
}
private:
void
doWork();

90
reporting/server/SubscriptionManager.cpp Normal file
View File

@@ -0,0 +1,90 @@
#include<reporting/server/SubscriptionManager.h>
#include<handlers/RPCHelpers.h>
void
SubscriptionManager::subLedger(std::shared_ptr<session>& session)
{
streamSubscribers_[Ledgers].emplace(std::move(session));
}
void
SubscriptionManager::unsubLedger(std::shared_ptr<session>& session)
{
streamSubscribers_[Ledgers].erase(session);
}
void
SubscriptionManager::pubLedger(
ripple::LedgerInfo const& lgrInfo,
ripple::Fees const& fees,
std::string const& ledgerRange,
std::uint32_t txnCount)
{
boost::json::object pubMsg;
pubMsg["type"] = "ledgerClosed";
pubMsg["ledger_index"] = lgrInfo.seq;
pubMsg["ledger_hash"] = to_string(lgrInfo.hash);
pubMsg["ledger_time"] = lgrInfo.closeTime.time_since_epoch().count();
pubMsg["fee_ref"] = getJson(fees.units.jsonClipped());
pubMsg["fee_base"] = getJson(fees.base.jsonClipped());
pubMsg["reserve_base"] = getJson(fees.accountReserve(0).jsonClipped());
pubMsg["reserve_inc"] = getJson(fees.increment.jsonClipped());
pubMsg["validated_ledgers"] = ledgerRange;
pubMsg["txn_count"] = txnCount;
for (auto const& session: streamSubscribers_[Ledgers])
session->send(boost::json::serialize(pubMsg));
}
void
SubscriptionManager::subTransactions(std::shared_ptr<session>& session)
{
streamSubscribers_[Transactions].emplace(std::move(session));
}
void
SubscriptionManager::unsubTransactions(std::shared_ptr<session>& session)
{
streamSubscribers_[Transactions].erase(session);
}
void
SubscriptionManager::subAccount(
ripple::AccountID const& account,
std::shared_ptr<session>& session)
{
accountSubscribers_[account].emplace(std::move(session));
}
void
SubscriptionManager::unsubAccount(
ripple::AccountID const& account,
std::shared_ptr<session>& session)
{
accountSubscribers_[account].erase(session);
}
void
SubscriptionManager::pubTransaction(
Backend::TransactionAndMetadata const& blob,
std::uint32_t seq)
{
auto [tx, meta] = deserializeTxPlusMeta(blob, seq);
boost::json::object pubMsg;
pubMsg["transaction"] = getJson(*tx);
pubMsg["meta"] = getJson(*meta);
for (auto const& session: streamSubscribers_[Transactions])
session->send(boost::json::serialize(pubMsg));
auto journal = ripple::debugLog();
auto accounts = meta->getAffectedAccounts(journal);
for (ripple::AccountID const& account : accounts)
for (auto const& session: accountSubscribers_[account])
session->send(boost::json::serialize(pubMsg));
}

75
reporting/server/SubscriptionManager.h Normal file
View File

@@ -0,0 +1,75 @@
//------------------------------------------------------------------------------
/*
This file is part of rippled: https://github.com/ripple/rippled
Copyright (c) 2020 Ripple Labs Inc.
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
ANY SPECIAL , DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
//==============================================================================
#ifndef SUBSCRIPTION_MANAGER_H
#define SUBSCRIPTION_MANAGER_H
#include <reporting/server/session.h>
#include <set>
#include <memory>
class session;
class SubscriptionManager
{
using subscriptions = std::set<std::shared_ptr<session>>;
enum SubscriptionType {
Ledgers,
Transactions,
finalEntry
};
std::array<subscriptions, finalEntry> streamSubscribers_;
std::unordered_map<ripple::AccountID, subscriptions> accountSubscribers_;
public:
void
subLedger(std::shared_ptr<session>& session);
void
pubLedger(
ripple::LedgerInfo const& lgrInfo,
ripple::Fees const& fees,
std::string const& ledgerRange,
std::uint32_t txnCount);
void
unsubLedger(std::shared_ptr<session>& session);
void
subTransactions(std::shared_ptr<session>& session);
void
unsubTransactions(std::shared_ptr<session>& session);
void
pubTransaction(Backend::TransactionAndMetadata const& blob, std::uint32_t seq);
void
subAccount(ripple::AccountID const& account, std::shared_ptr<session>& session);
void
unsubAccount(ripple::AccountID const& account, std::shared_ptr<session>& session);
};
#endif //SUBSCRIPTION_MANAGER_H

124
reporting/server/listener.h Normal file
View File

@@ -0,0 +1,124 @@
//------------------------------------------------------------------------------
/*
This file is part of rippled: https://github.com/ripple/rippled
Copyright (c) 2020 Ripple Labs Inc.
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
ANY SPECIAL , DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
//==============================================================================
#ifndef LISTENER_H
#define LISTENER_H
#include <boost/asio/dispatch.hpp>
#include <boost/beast/core.hpp>
#include <boost/beast/websocket.hpp>
#include <reporting/server/SubscriptionManager.h>
#include <iostream>
class SubscriptionManager;
// Accepts incoming connections and launches the sessions
// Accepts incoming connections and launches the sessions
class listener : public std::enable_shared_from_this<listener>
{
boost::asio::io_context& ioc_;
boost::asio::ip::tcp::acceptor acceptor_;
BackendInterface const& backend_;
SubscriptionManager& subscriptions_;
public:
listener(
boost::asio::io_context& ioc,
boost::asio::ip::tcp::endpoint endpoint,
SubscriptionManager& subs,
BackendInterface const& backend)
: ioc_(ioc)
, acceptor_(ioc)
, backend_(backend)
, subscriptions_(subs)
{
boost::beast::error_code ec;
// Open the acceptor
acceptor_.open(endpoint.protocol(), ec);
if (ec)
{
fail(ec, "open");
return;
}
// Allow address reuse
acceptor_.set_option(boost::asio::socket_base::reuse_address(true), ec);
if (ec)
{
fail(ec, "set_option");
return;
}
// Bind to the server address
acceptor_.bind(endpoint, ec);
if (ec)
{
fail(ec, "bind");
return;
}
// Start listening for connections
acceptor_.listen(boost::asio::socket_base::max_listen_connections, ec);
if (ec)
{
fail(ec, "listen");
return;
}
}
// Start accepting incoming connections
void
run()
{
do_accept();
}
private:
void
do_accept()
{
// The new connection gets its own strand
acceptor_.async_accept(
boost::asio::make_strand(ioc_),
boost::beast::bind_front_handler(
&listener::on_accept, shared_from_this()));
}
void
on_accept(boost::beast::error_code ec, boost::asio::ip::tcp::socket socket)
{
if (ec)
{
fail(ec, "accept");
}
else
{
// Create the session and run it
std::make_shared<session>(std::move(socket), subscriptions_, backend_)->run();
}
// Accept another connection
do_accept();
}
};
#endif // LISTENER_H

39
reporting/server/session.cpp
View File

@@ -8,39 +8,50 @@ fail(boost::beast::error_code ec, char const* what)
boost::json::object
buildResponse(
boost::json::object const& request,
boost::json::object const& request,
BackendInterface const& backend,
SubscriptionManager& subManager,
SubscriptionManager& manager,
std::shared_ptr<session> session)
{
std::string command = request.at("command").as_string().c_str();
BOOST_LOG_TRIVIAL(info) << "Received rpc command : " << request;
boost::json::object response;
switch (commandMap[command])
{
case tx:
return doTx(request, backend);
break;
case account_tx:
return doAccountTx(request, backend);
break;
case book_offers:
return doBookOffers(request, backend);
break;
case ledger:
return doLedger(request, backend);
break;
case ledger_entry:
return doLedgerEntry(request, backend);
case ledger_range:
return doLedgerRange(request, backend);
case ledger_data:
return doLedgerData(request, backend);
break;
case account_info:
return doAccountInfo(request, backend);
break;
case book_offers:
return doBookOffers(request, backend);
case account_channels:
return doAccountChannels(request, backend);
case account_lines:
return doAccountLines(request, backend);
case account_currencies:
return doAccountCurrencies(request, backend);
case account_offers:
return doAccountOffers(request, backend);
case account_objects:
return doAccountObjects(request, backend);
case channel_authorize:
return doChannelAuthorize(request);
case channel_verify:
return doChannelVerify(request);
case subscribe:
return doSubscribe(request, session, subManager);
break;
return doSubscribe(request, session, manager);
case unsubscribe:
return doUnsubscribe(request, session, subManager);
break;
return doUnsubscribe(request, session, manager);
default:
BOOST_LOG_TRIVIAL(error) << "Unknown command: " << command;
}

98
reporting/server/session.h
View File

@@ -31,21 +31,46 @@
class session;
class SubscriptionManager;
static enum RPCCommand { tx, account_tx, ledger, account_info, book_offers, ledger_data, subscribe, unsubscribe };
static std::unordered_map<std::string, RPCCommand> commandMap{
{"tx", tx},
{"account_tx", account_tx},
{"ledger", ledger},
{"account_info", account_info},
{"book_offers", book_offers},
{"ledger_data", ledger_data},
{"subscribe", subscribe},
{"unsubscribe", unsubscribe}};
//------------------------------------------------------------------------------
enum RPCCommand {
tx,
account_tx,
ledger,
account_info,
ledger_data,
book_offers,
ledger_range,
ledger_entry,
account_channels,
account_lines,
account_currencies,
account_offers,
account_objects,
channel_authorize,
channel_verify,
subscribe,
unsubscribe
};
static std::unordered_map<std::string, RPCCommand> commandMap{
{"tx", tx},
{"account_tx", account_tx},
{"ledger", ledger},
{"ledger_range", ledger_range},
{"ledger_entry", ledger_entry},
{"account_info", account_info},
{"ledger_data", ledger_data},
{"book_offers", book_offers},
{"account_channels", account_channels},
{"account_lines", account_lines},
{"account_currencies", account_currencies},
{"account_offers", account_offers},
{"account_objects", account_objects},
{"channel_authorize", channel_authorize},
{"channel_verify", channel_verify},
{"subscribe", subscribe},
{"unsubscribe", unsubscribe}};
boost::json::object
doAccountInfo(
boost::json::object const& request,
BackendInterface const& backend);
boost::json::object
doTx(
boost::json::object const& request,
@@ -54,18 +79,59 @@ boost::json::object
doAccountTx(
boost::json::object const& request,
BackendInterface const& backend);
boost::json::object
doBookOffers(
boost::json::object const& request,
BackendInterface const& backend);
boost::json::object
doLedgerData(
boost::json::object const& request,
BackendInterface const& backend);
boost::json::object
doLedgerEntry(
boost::json::object const& request,
BackendInterface const& backend);
boost::json::object
doLedger(
boost::json::object const& request,
BackendInterface const& backend);
boost::json::object
doLedgerRange(
boost::json::object const& request,
BackendInterface const& backend);
boost::json::object
doAccountInfo(
boost::json::object const& request,
BackendInterface const& backend);
boost::json::object
doAccountChannels(
boost::json::object const& request,
BackendInterface const& backend);
boost::json::object
doAccountLines(
boost::json::object const& request,
BackendInterface const& backend);
boost::json::object
doAccountCurrencies(
boost::json::object const& request,
BackendInterface const& backend);
boost::json::object
doAccountOffers(
boost::json::object const& request,
BackendInterface const& backend);
boost::json::object
doAccountObjects(
boost::json::object const& request,
BackendInterface const& backend);
boost::json::object
doChannelAuthorize(boost::json::object const& request);
boost::json::object
doChannelVerify(boost::json::object const& request);
boost::json::object
doSubscribe(
boost::json::object const& request,
@@ -79,9 +145,9 @@ doUnsubscribe(
boost::json::object
buildResponse(
boost::json::object const& request,
boost::json::object const& request,
BackendInterface const& backend,
SubscriptionManager& subManager,
SubscriptionManager& manager,
std::shared_ptr<session> session);
void

368
websocket_server_async.cpp
View File

@@ -29,376 +29,13 @@
#include <iostream>
#include <memory>
#include <reporting/ReportingETL.h>
#include <reporting/server/session.h>
#include <reporting/server/listener.h>
#include <sstream>
#include <string>
#include <thread>
#include <vector>
//------------------------------------------------------------------------------
enum RPCCommand {
tx,
account_tx,
ledger,
account_info,
ledger_data,
book_offers,
ledger_range,
ledger_entry,
account_channels,
account_lines,
account_currencies,
account_offers,
account_objects
channel_authorize,
channel_verify
};
std::unordered_map<std::string, RPCCommand> commandMap{
{"tx", tx},
{"account_tx", account_tx},
{"ledger", ledger},
{"ledger_range", ledger_range},
{"ledger_entry", ledger_entry},
{"account_info", account_info},
{"ledger_data", ledger_data},
{"book_offers", book_offers},
{"account_channels", account_channels},
{"account_lines", account_lines},
{"account_currencies", account_currencies},
{"account_offers", account_offers},
{"account_objects", account_objects},
{"channel_authorize", channel_authorize},
{"channel_verify", channel_verify}};
boost::json::object
doAccountInfo(
boost::json::object const& request,
BackendInterface const& backend);
boost::json::object
doTx(boost::json::object const& request, BackendInterface const& backend);
boost::json::object
doAccountTx(
boost::json::object const& request,
BackendInterface const& backend);
boost::json::object
doLedgerData(
boost::json::object const& request,
BackendInterface const& backend);
boost::json::object
doLedgerEntry(
boost::json::object const& request,
BackendInterface const& backend);
boost::json::object
doBookOffers(
boost::json::object const& request,
BackendInterface const& backend);
boost::json::object
doLedger(boost::json::object const& request, BackendInterface const& backend);
boost::json::object
doLedgerRange(
boost::json::object const& request,
BackendInterface const& backend);
boost::json::object
doAccountChannels(
boost::json::object const& request,
BackendInterface const& backend);
boost::json::object
doAccountLines(
boost::json::object const& request,
BackendInterface const& backend);
boost::json::object
doAccountCurrencies(
boost::json::object const& request,
BackendInterface const& backend);
boost::json::object
doAccountOffers(
boost::json::object const& request,
BackendInterface const& backend);
boost::json::object
doAccountObjects(
boost::json::object const& request,
BackendInterface const& backend);
doChannelAuthorize(boost::json::object const& request);
boost::json::object
doChannelVerify(boost::json::object const& request);
boost::json::object
buildResponse(
boost::json::object const& request,
BackendInterface const& backend)
{
std::string command = request.at("command").as_string().c_str();
BOOST_LOG_TRIVIAL(info) << "Received rpc command : " << request;
boost::json::object response;
switch (commandMap[command])
{
case tx:
return doTx(request, backend);
case account_tx:
return doAccountTx(request, backend);
case ledger:
return doLedger(request, backend);
case ledger_entry:
return doLedgerEntry(request, backend);
case ledger_range:
return doLedgerRange(request, backend);
case ledger_data:
return doLedgerData(request, backend);
case account_info:
return doAccountInfo(request, backend);
case book_offers:
return doBookOffers(request, backend);
case account_channels:
return doAccountChannels(request, backend);
case account_lines:
return doAccountLines(request, backend);
case account_currencies:
return doAccountCurrencies(request, backend);
case account_offers:
return doAccountOffers(request, backend);
case account_objects:
return doAccountObjects(request, backend);
case channel_authorize:
return doChannelAuthorize(request);
case channel_verify:
return doChannelVerify(request);
break;
default:
BOOST_LOG_TRIVIAL(error) << "Unknown command: " << command;
}
return response;
}
// Report a failure
void
fail(boost::beast::error_code ec, char const* what)
{
std::cerr << what << ": " << ec.message() << "\n";
}
// Echoes back all received WebSocket messages
class session : public std::enable_shared_from_this<session>
{
boost::beast::websocket::stream<boost::beast::tcp_stream> ws_;
boost::beast::flat_buffer buffer_;
std::string response_;
BackendInterface const& backend_;
public:
// Take ownership of the socket
explicit session(
boost::asio::ip::tcp::socket&& socket,
BackendInterface const& backend)
: ws_(std::move(socket)), backend_(backend)
{
}
// Get on the correct executor
void
run()
{
// We need to be executing within a strand to perform async operations
// on the I/O objects in this session. Although not strictly necessary
// for single-threaded contexts, this example code is written to be
// thread-safe by default.
boost::asio::dispatch(
ws_.get_executor(),
boost::beast::bind_front_handler(
&session::on_run, shared_from_this()));
}
// Start the asynchronous operation
void
on_run()
{
// Set suggested timeout settings for the websocket
ws_.set_option(boost::beast::websocket::stream_base::timeout::suggested(
boost::beast::role_type::server));
// Set a decorator to change the Server of the handshake
ws_.set_option(boost::beast::websocket::stream_base::decorator(
[](boost::beast::websocket::response_type& res) {
res.set(
boost::beast::http::field::server,
std::string(BOOST_BEAST_VERSION_STRING) +
" websocket-server-async");
}));
// Accept the websocket handshake
ws_.async_accept(boost::beast::bind_front_handler(
&session::on_accept, shared_from_this()));
}
void
on_accept(boost::beast::error_code ec)
{
if (ec)
return fail(ec, "accept");
// Read a message
do_read();
}
void
do_read()
{
// Read a message into our buffer
ws_.async_read(
buffer_,
boost::beast::bind_front_handler(
&session::on_read, shared_from_this()));
}
void
on_read(boost::beast::error_code ec, std::size_t bytes_transferred)
{
boost::ignore_unused(bytes_transferred);
// This indicates that the session was closed
if (ec == boost::beast::websocket::error::closed)
return;
if (ec)
fail(ec, "read");
std::string msg{
static_cast<char const*>(buffer_.data().data()), buffer_.size()};
// BOOST_LOG_TRIVIAL(debug) << __func__ << msg;
boost::json::object response;
try
{
boost::json::value raw = boost::json::parse(msg);
boost::json::object request = raw.as_object();
BOOST_LOG_TRIVIAL(debug) << " received request : " << request;
try
{
auto start = std::chrono::system_clock::now();
response = buildResponse(request, backend_);
auto end = std::chrono::system_clock::now();
BOOST_LOG_TRIVIAL(info) << __func__ << " RPC call took " << ((end - start).count() / 1000000000.0) << " . request = " << request;
}
catch (Backend::DatabaseTimeout const& t)
{
BOOST_LOG_TRIVIAL(error) << __func__ << " Database timeout";
response["error"] =
"Database read timeout. Please retry the request";
}
}
catch (std::exception const& e)
{
BOOST_LOG_TRIVIAL(error)
<< __func__ << "caught exception : " << e.what();
}
BOOST_LOG_TRIVIAL(trace) << __func__ << response;
response_ = boost::json::serialize(response);
// Echo the message
ws_.text(ws_.got_text());
ws_.async_write(
boost::asio::buffer(response_),
boost::beast::bind_front_handler(
&session::on_write, shared_from_this()));
}
void
on_write(boost::beast::error_code ec, std::size_t bytes_transferred)
{
boost::ignore_unused(bytes_transferred);
if (ec)
return fail(ec, "write");
// Clear the buffer
buffer_.consume(buffer_.size());
// Do another read
do_read();
}
};
//------------------------------------------------------------------------------
// Accepts incoming connections and launches the sessions
class listener : public std::enable_shared_from_this<listener>
{
boost::asio::io_context& ioc_;
boost::asio::ip::tcp::acceptor acceptor_;
BackendInterface const& backend_;
public:
listener(
boost::asio::io_context& ioc,
boost::asio::ip::tcp::endpoint endpoint,
BackendInterface const& backend)
: ioc_(ioc), acceptor_(ioc), backend_(backend)
{
boost::beast::error_code ec;
// Open the acceptor
acceptor_.open(endpoint.protocol(), ec);
if (ec)
{
fail(ec, "open");
return;
}
// Allow address reuse
acceptor_.set_option(boost::asio::socket_base::reuse_address(true), ec);
if (ec)
{
fail(ec, "set_option");
return;
}
// Bind to the server address
acceptor_.bind(endpoint, ec);
if (ec)
{
fail(ec, "bind");
return;
}
// Start listening for connections
acceptor_.listen(boost::asio::socket_base::max_listen_connections, ec);
if (ec)
{
fail(ec, "listen");
return;
}
}
// Start accepting incoming connections
void
run()
{
do_accept();
}
private:
void
do_accept()
{
// The new connection gets its own strand
acceptor_.async_accept(
boost::asio::make_strand(ioc_),
boost::beast::bind_front_handler(
&listener::on_accept, shared_from_this()));
}
void
on_accept(boost::beast::error_code ec, boost::asio::ip::tcp::socket socket)
{
if (ec)
{
fail(ec, "accept");
}
else
{
// Create the session and run it
std::make_shared<session>(std::move(socket), backend_)->run();
}
// Accept another connection
do_accept();
}
};
std::optional<boost::json::object>
parse_config(const char* filename)
{
@@ -497,6 +134,7 @@ main(int argc, char* argv[])
std::make_shared<listener>(
ioc,
boost::asio::ip::tcp::endpoint{address, port},
etl.getSubscriptionManager(),
etl.getFlatMapBackend())
->run();