BasePeer.h

#ifndef XRPL_SERVER_BASEPEER_H_INCLUDED
#define XRPL_SERVER_BASEPEER_H_INCLUDED
 
#include <xrpl/beast/utility/WrappedSink.h>
#include <xrpl/beast/utility/instrumentation.h>
#include <xrpl/server/Port.h>
#include <xrpl/server/detail/LowestLayer.h>
#include <xrpl/server/detail/io_list.h>
 
#include <boost/asio.hpp>
 
#include <atomic>
#include <functional>
#include <string>
 
namespace ripple {
 
// Common part of all peers
template <class Handler, class Impl>
class BasePeer : public io_list::work
{
protected:
    using clock_type = std::chrono::system_clock;
    using error_code = boost::system::error_code;
    using endpoint_type = boost::asio::ip::tcp::endpoint;
    using waitable_timer = boost::asio::basic_waitable_timer<clock_type>;
 
    Port const& port_;
    Handler& handler_;
    endpoint_type remote_address_;
    beast::WrappedSink sink_;
    beast::Journal const j_;
 
    boost::asio::executor_work_guard<boost::asio::executor> work_;
    boost::asio::strand<boost::asio::executor> strand_;
 
public:
    BasePeer(
        Port const& port,
        Handler& handler,
        boost::asio::executor const& executor,
        endpoint_type remote_address,
        beast::Journal journal);
 
    void
    close() override;
 
private:
    Impl&
    impl()
    {
        return *static_cast<Impl*>(this);
    }
};
 
//------------------------------------------------------------------------------
 
template <class Handler, class Impl>
BasePeer<Handler, Impl>::BasePeer(
    Port const& port,
    Handler& handler,
    boost::asio::executor const& executor,
    endpoint_type remote_address,
    beast::Journal journal)
    : port_(port)
    , handler_(handler)
    , remote_address_(remote_address)
    , sink_(
          journal.sink(),
          [] {
              static std::atomic<unsigned> id{0};
              return "##" + std::to_string(++id) + " ";
          }())
    , j_(sink_)
    , work_(boost::asio::make_work_guard(executor))
    , strand_(boost::asio::make_strand(executor))
{
}
 
template <class Handler, class Impl>
void
BasePeer<Handler, Impl>::close()
{
    if (!strand_.running_in_this_thread())
        return post(
            strand_, std::bind(&BasePeer::close, impl().shared_from_this()));
    error_code ec;
    ripple::get_lowest_layer(impl().ws_).socket().close(ec);
}
 
}  // namespace ripple
 
#endif