refactor: rename ServerHandlerImp to ServerHandler (#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

@@ -670,7 +670,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,215 @@
 #ifndef RIPPLE_RPC_SERVERHANDLER_H_INCLUDED
 #define RIPPLE_RPC_SERVERHANDLER_H_INCLUDED
 
-#include <ripple/basics/BasicConfig.h>
+#include <ripple/app/main/CollectorManager.h>
-#include <ripple/beast/utility/Journal.h>
-#include <ripple/core/Config.h>
 #include <ripple/core/JobQueue.h>
-#include <ripple/resource/ResourceManager.h>
+#include <ripple/json/Output.h>
-#include <ripple/rpc/impl/ServerHandlerImp.h>
+#include <ripple/rpc/RPCHandler.h>
-#include <ripple/server/Port.h>
+#include <ripple/rpc/impl/UDPInfoSub.h>
-#include <boost/asio/io_service.hpp>
+#include <ripple/rpc/impl/WSInfoSub.h>
-#include <boost/asio/ip/address.hpp>
+#include <ripple/server/Server.h>
-#include <memory>
+#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
+    onUDPMessage(
+        std::string const& message,
+        boost::asio::ip::tcp::endpoint const& remoteEndpoint,
+        std::function<void(std::string const&)> sendResponse);
+
+    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);
+
+    Json::Value
+    processUDP(
+        Json::Value const& jv,
+        Role const& role,
+        std::shared_ptr<JobQueue::Coro> const& coro,
+        std::optional<std::function<void(std::string const&)>> sendResponse,
+        boost::asio::ip::tcp::endpoint const& remoteEndpoint);
+
+    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/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,7 +363,7 @@ ServerHandlerImp::onWSMessage(
 }
 
 void
-ServerHandlerImp::onUDPMessage(
+ServerHandler::onUDPMessage(
     std::string const& message,
     boost::asio::ip::tcp::endpoint const& remoteEndpoint,
     std::function<void(std::string const&)> sendResponse)
@@ -423,14 +424,14 @@ ServerHandlerImp::onUDPMessage(
 }
 
 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;
@@ -459,7 +460,7 @@ logDuration(
 }
 
 Json::Value
-ServerHandlerImp::processUDP(
+ServerHandler::processUDP(
     Json::Value const& jv,
     Role const& role,
     std::shared_ptr<JobQueue::Coro> const& coro,
@@ -593,7 +594,7 @@ ServerHandlerImp::processUDP(
 }
 
 Json::Value
-ServerHandlerImp::processSession(
+ServerHandler::processSession(
     std::shared_ptr<WSSession> const& session,
     std::shared_ptr<JobQueue::Coro> const& coro,
     Json::Value const& jv)
@@ -740,7 +741,7 @@ ServerHandlerImp::processSession(
 
 // Run as a coroutine.
 void
-ServerHandlerImp::processSession(
+ServerHandler::processSession(
     std::shared_ptr<Session> const& session,
     std::shared_ptr<JobQueue::Coro> coro)
 {
@@ -781,7 +782,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,
@@ -1217,7 +1218,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;
@@ -1447,8 +1448,14 @@ make_ServerHandler(
     Resource::Manager& resourceManager,
     CollectorManager& cm)
 {
-    return std::make_unique<ServerHandlerImp>(
+    return std::make_unique<ServerHandler>(
-        app, io_service, jobQueue, networkOPs, resourceManager, cm);
+        ServerHandler::ServerHandlerCreator(),
+        app,
+        io_service,
+        jobQueue,
+        networkOPs,
+        resourceManager,
+        cm);
 }
 
 }  // namespace ripple