Skip to content

Commit

Permalink
refactor: rename ServerHandlerImp to ServerHandler (#4516)
Browse files Browse the repository at this point in the history
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.
  • Loading branch information
scottschurr authored Jun 28, 2023
1 parent 0e98352 commit 11e914f
Show file tree
Hide file tree
Showing 4 changed files with 215 additions and 230 deletions.
2 changes: 1 addition & 1 deletion Builds/CMake/RippledCore.cmake
Original file line number Diff line number Diff line change
Expand Up @@ -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
Expand Down
199 changes: 189 additions & 10 deletions src/ripple/rpc/ServerHandler.h
Original file line number Diff line number Diff line change
Expand Up @@ -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);
Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -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>
Expand All @@ -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>
Expand Down Expand Up @@ -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,
Expand All @@ -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);
Expand All @@ -136,7 +137,7 @@ ServerHandlerImp::setup(Setup const& setup, beast::Journal journal)
//------------------------------------------------------------------------------

void
ServerHandlerImp::stop()
ServerHandler::stop()
{
m_server->close();
{
Expand All @@ -148,7 +149,7 @@ ServerHandlerImp::stop()
//------------------------------------------------------------------------------

bool
ServerHandlerImp::onAccept(
ServerHandler::onAccept(
Session& session,
boost::asio::ip::tcp::endpoint endpoint)
{
Expand All @@ -170,7 +171,7 @@ ServerHandlerImp::onAccept(
}

Handoff
ServerHandlerImp::onHandoff(
ServerHandler::onHandoff(
Session& session,
std::unique_ptr<stream_type>&& bundle,
http_request_type&& request,
Expand Down Expand Up @@ -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 &&
Expand Down Expand Up @@ -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)
{
Expand Down Expand Up @@ -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;
Expand Down Expand Up @@ -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)
Expand Down Expand Up @@ -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)
{
Expand Down Expand Up @@ -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,
Expand Down Expand Up @@ -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;
Expand Down Expand Up @@ -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
Loading

0 comments on commit 11e914f

Please sign in to comment.