refactor: rename ServerHandlerImp to ServerHandler (XRPLF#4516)

Rename `ServerHandlerImp` to `ServerHandler`. There was no other
ServerHandler definition despite the existence of a header suggesting
that there was.

This resolves a piece of historical confusion in the code, which was
identified during a code review.

The changes in the diff may look more extensive than they actually are.
The contents of `impl/ServerHandlerImp.h` were merged into
`ServerHandler.h`, making the latter file appear to have undergone
significant modifications. However, this is a non-breaking refactor that
only restructures code.

Builds/CMake/RippledCore.cmake

@@ -692,7 +692,7 @@ target_sources (rippled PRIVATE
  src/ripple/rpc/impl/RPCHandler.cpp
  src/ripple/rpc/impl/RPCHelpers.cpp
  src/ripple/rpc/impl/Role.cpp
- src/ripple/rpc/impl/ServerHandlerImp.cpp
+ src/ripple/rpc/impl/ServerHandler.cpp
  src/ripple/rpc/impl/ShardArchiveHandler.cpp
  src/ripple/rpc/impl/ShardVerificationScheduler.cpp
  src/ripple/rpc/impl/Status.cpp

src/ripple/rpc/ServerHandler.h

@@ -20,21 +20,200 @@
 #ifndef RIPPLE_RPC_SERVERHANDLER_H_INCLUDED
 #define RIPPLE_RPC_SERVERHANDLER_H_INCLUDED
 
-#include <ripple/basics/BasicConfig.h>
-#include <ripple/beast/utility/Journal.h>
-#include <ripple/core/Config.h>
+#include <ripple/app/main/CollectorManager.h>
 #include <ripple/core/JobQueue.h>
-#include <ripple/resource/ResourceManager.h>
-#include <ripple/rpc/impl/ServerHandlerImp.h>
-#include <ripple/server/Port.h>
-#include <boost/asio/io_service.hpp>
-#include <boost/asio/ip/address.hpp>
-#include <memory>
+#include <ripple/json/Output.h>
+#include <ripple/rpc/RPCHandler.h>
+#include <ripple/rpc/impl/WSInfoSub.h>
+#include <ripple/server/Server.h>
+#include <ripple/server/Session.h>
+#include <ripple/server/WSSession.h>
+#include <boost/beast/core/tcp_stream.hpp>
+#include <boost/beast/ssl/ssl_stream.hpp>
+#include <boost/utility/string_view.hpp>
+#include <condition_variable>
+#include <map>
+#include <mutex>
 #include <vector>
 
 namespace ripple {
 
-using ServerHandler = ServerHandlerImp;
+inline bool
+operator<(Port const& lhs, Port const& rhs)
+{
+ return lhs.name < rhs.name;
+}
+
+class ServerHandler
+{
+public:
+ struct Setup
+ {
+ explicit Setup() = default;
+
+ std::vector<Port> ports;
+
+ // Memberspace
+ struct client_t
+ {
+ explicit client_t() = default;
+
+ bool secure = false;
+ std::string ip;
+ std::uint16_t port = 0;
+ std::string user;
+ std::string password;
+ std::string admin_user;
+ std::string admin_password;
+ };
+
+ // Configuration when acting in client role
+ client_t client;
+
+ // Configuration for the Overlay
+ struct overlay_t
+ {
+ explicit overlay_t() = default;
+
+ boost::asio::ip::address ip;
+ std::uint16_t port = 0;
+ };
+
+ overlay_t overlay;
+
+ void
+ makeContexts();
+ };
+
+private:
+ using socket_type = boost::beast::tcp_stream;
+ using stream_type = boost::beast::ssl_stream<socket_type>;
+
+ Application& app_;
+ Resource::Manager& m_resourceManager;
+ beast::Journal m_journal;
+ NetworkOPs& m_networkOPs;
+ std::unique_ptr<Server> m_server;
+ Setup setup_;
+ JobQueue& m_jobQueue;
+ beast::insight::Counter rpc_requests_;
+ beast::insight::Event rpc_size_;
+ beast::insight::Event rpc_time_;
+ std::mutex mutex_;
+ std::condition_variable condition_;
+ bool stopped_{false};
+ std::map<std::reference_wrapper<Port const>, int> count_;
+
+ // A private type used to restrict access to the ServerHandler constructor.
+ struct ServerHandlerCreator
+ {
+ explicit ServerHandlerCreator() = default;
+ };
+
+ // Friend declaration that allows make_ServerHandler to access the
+ // private type that restricts access to the ServerHandler ctor.
+ friend std::unique_ptr<ServerHandler>
+ make_ServerHandler(
+ Application& app,
+ boost::asio::io_service&,
+ JobQueue&,
+ NetworkOPs&,
+ Resource::Manager&,
+ CollectorManager& cm);
+
+public:
+ // Must be public so make_unique can call it.
+ ServerHandler(
+ ServerHandlerCreator const&,
+ Application& app,
+ boost::asio::io_service& io_service,
+ JobQueue& jobQueue,
+ NetworkOPs& networkOPs,
+ Resource::Manager& resourceManager,
+ CollectorManager& cm);
+
+ ~ServerHandler();
+
+ using Output = Json::Output;
+
+ void
+ setup(Setup const& setup, beast::Journal journal);
+
+ Setup const&
+ setup() const
+ {
+ return setup_;
+ }
+
+ void
+ stop();
+
+ //
+ // Handler
+ //
+
+ bool
+ onAccept(Session& session, boost::asio::ip::tcp::endpoint endpoint);
+
+ Handoff
+ onHandoff(
+ Session& session,
+ std::unique_ptr<stream_type>&& bundle,
+ http_request_type&& request,
+ boost::asio::ip::tcp::endpoint const& remote_address);
+
+ Handoff
+ onHandoff(
+ Session& session,
+ http_request_type&& request,
+ boost::asio::ip::tcp::endpoint const& remote_address)
+ {
+ return onHandoff(
+ session,
+ {},
+ std::forward<http_request_type>(request),
+ remote_address);
+ }
+
+ void
+ onRequest(Session& session);
+
+ void
+ onWSMessage(
+ std::shared_ptr<WSSession> session,
+ std::vector<boost::asio::const_buffer> const& buffers);
+
+ void
+ onClose(Session& session, boost::system::error_code const&);
+
+ void
+ onStopped(Server&);
+
+private:
+ Json::Value
+ processSession(
+ std::shared_ptr<WSSession> const& session,
+ std::shared_ptr<JobQueue::Coro> const& coro,
+ Json::Value const& jv);
+
+ void
+ processSession(
+ std::shared_ptr<Session> const&,
+ std::shared_ptr<JobQueue::Coro> coro);
+
+ void
+ processRequest(
+ Port const& port,
+ std::string const& request,
+ beast::IP::Endpoint const& remoteIPAddress,
+ Output&&,
+ std::shared_ptr<JobQueue::Coro> coro,
+ boost::string_view forwardedFor,
+ boost::string_view user);
+
+ Handoff
+ statusResponse(http_request_type const& request) const;
+};
 
 ServerHandler::Setup
 setup_ServerHandler(Config const& c, std::ostream&& log);

src/ripple/rpc/impl/ServerHandlerImp.cpp → src/ripple/rpc/impl/ServerHandler.cpp

@@ -17,6 +17,8 @@
 */
 //==============================================================================
 
+#include <ripple/rpc/ServerHandler.h>
+
 #include <ripple/app/main/Application.h>
 #include <ripple/app/misc/NetworkOPs.h>
 #include <ripple/basics/Log.h>
@@ -35,9 +37,7 @@
 #include <ripple/resource/ResourceManager.h>
 #include <ripple/rpc/RPCHandler.h>
 #include <ripple/rpc/Role.h>
-#include <ripple/rpc/ServerHandler.h>
 #include <ripple/rpc/impl/RPCHelpers.h>
-#include <ripple/rpc/impl/ServerHandlerImp.h>
 #include <ripple/rpc/impl/Tuning.h>
 #include <ripple/rpc/json_body.h>
 #include <ripple/server/Server.h>
@@ -101,7 +101,8 @@ authorized(Port const& port, std::map<std::string, std::string> const& h)
  return strUser == port.user && strPassword == port.password;
 }
 
-ServerHandlerImp::ServerHandlerImp(
+ServerHandler::ServerHandler(
+ ServerHandlerCreator const&,
  Application& app,
  boost::asio::io_service& io_service,
  JobQueue& jobQueue,
@@ -121,13 +122,13 @@ ServerHandlerImp::ServerHandlerImp(
  rpc_time_ = group->make_event("time");
 }
 
-ServerHandlerImp::~ServerHandlerImp()
+ServerHandler::~ServerHandler()
 {
  m_server = nullptr;
 }
 
 void
-ServerHandlerImp::setup(Setup const& setup, beast::Journal journal)
+ServerHandler::setup(Setup const& setup, beast::Journal journal)
 {
  setup_ = setup;
  m_server->ports(setup.ports);
@@ -136,7 +137,7 @@ ServerHandlerImp::setup(Setup const& setup, beast::Journal journal)
 //------------------------------------------------------------------------------
 
 void
-ServerHandlerImp::stop()
+ServerHandler::stop()
 {
  m_server->close();
  {
@@ -148,7 +149,7 @@ ServerHandlerImp::stop()
 //------------------------------------------------------------------------------
 
 bool
-ServerHandlerImp::onAccept(
+ServerHandler::onAccept(
  Session& session,
  boost::asio::ip::tcp::endpoint endpoint)
 {
@@ -170,7 +171,7 @@ ServerHandlerImp::onAccept(
 }
 
 Handoff
-ServerHandlerImp::onHandoff(
+ServerHandler::onHandoff(
  Session& session,
  std::unique_ptr<stream_type>&& bundle,
  http_request_type&& request,
@@ -272,7 +273,7 @@ buffers_to_string(ConstBufferSequence const& bs)
 }
 
 void
-ServerHandlerImp::onRequest(Session& session)
+ServerHandler::onRequest(Session& session)
 {
  // Make sure RPC is enabled on the port
  if (session.port().protocol.count("http") == 0 &&
@@ -312,7 +313,7 @@ ServerHandlerImp::onRequest(Session& session)
 }
 
 void
-ServerHandlerImp::onWSMessage(
+ServerHandler::onWSMessage(
  std::shared_ptr<WSSession> session,
  std::vector<boost::asio::const_buffer> const& buffers)
 {
@@ -362,14 +363,14 @@ ServerHandlerImp::onWSMessage(
 }
 
 void
-ServerHandlerImp::onClose(Session& session, boost::system::error_code const&)
+ServerHandler::onClose(Session& session, boost::system::error_code const&)
 {
  std::lock_guard lock(mutex_);
  --count_[session.port()];
 }
 
 void
-ServerHandlerImp::onStopped(Server&)
+ServerHandler::onStopped(Server&)
 {
  std::lock_guard lock(mutex_);
  stopped_ = true;
@@ -398,7 +399,7 @@ logDuration(
 }
 
 Json::Value
-ServerHandlerImp::processSession(
+ServerHandler::processSession(
  std::shared_ptr<WSSession> const& session,
  std::shared_ptr<JobQueue::Coro> const& coro,
  Json::Value const& jv)
@@ -545,7 +546,7 @@ ServerHandlerImp::processSession(
 
 // Run as a coroutine.
 void
-ServerHandlerImp::processSession(
+ServerHandler::processSession(
  std::shared_ptr<Session> const& session,
  std::shared_ptr<JobQueue::Coro> coro)
 {
@@ -586,7 +587,7 @@ Json::Int constexpr forbidden = -32605;
 Json::Int constexpr wrong_version = -32606;
 
 void
-ServerHandlerImp::processRequest(
+ServerHandler::processRequest(
  Port const& port,
  std::string const& request,
  beast::IP::Endpoint const& remoteIPAddress,
@@ -1022,7 +1023,7 @@ ServerHandlerImp::processRequest(
  is reported, meaning the server can accept more connections.
 */
 Handoff
-ServerHandlerImp::statusResponse(http_request_type const& request) const
+ServerHandler::statusResponse(http_request_type const& request) const
 {
  using namespace boost::beast::http;
  Handoff handoff;
@@ -1252,8 +1253,14 @@ make_ServerHandler(
  Resource::Manager& resourceManager,
  CollectorManager& cm)
 {
- return std::make_unique<ServerHandlerImp>(
- app, io_service, jobQueue, networkOPs, resourceManager, cm);
+ return std::make_unique<ServerHandler>(
+ ServerHandler::ServerHandlerCreator(),
+ app,
+ io_service,
+ jobQueue,
+ networkOPs,
+ resourceManager,
+ cm);
 }
 
 } // namespace ripple