jsonrpc::endpoint::RpcEndpoint Class Reference

#include <endpoint.hpp>

Collaboration diagram for jsonrpc::endpoint::RpcEndpoint:

Public Member Functions
	RpcEndpoint (asio::any_io_executor executor, std::unique_ptr< transport::Transport > transport, std::shared_ptr< spdlog::logger > logger=nullptr)
	RpcEndpoint (const RpcEndpoint &)=delete
	RpcEndpoint (RpcEndpoint &&)=delete
auto	operator= (const RpcEndpoint &) -> RpcEndpoint &=delete
auto	operator= (RpcEndpoint &&) -> RpcEndpoint &=delete
	~RpcEndpoint ()=default
auto	Start () -> asio::awaitable< std::expected< void, RpcError > >
auto	WaitForShutdown () -> asio::awaitable< std::expected< void, RpcError > >
auto	Shutdown () -> asio::awaitable< std::expected< void, RpcError > >
auto	IsRunning () const -> bool
auto	Logger () -> std::shared_ptr< spdlog::logger >
auto	SendMethodCall (std::string method, std::optional< nlohmann::json > params=std::nullopt) -> asio::awaitable< std::expected< nlohmann::json, RpcError > >
template<typename ParamsType , typename ResultType >
auto	SendMethodCall (std::string method, ParamsType params) -> asio::awaitable< std::expected< ResultType, RpcError > > requires(ToJson< ParamsType > &&NotJsonLike< ParamsType > &&FromJson< ResultType >)
auto	SendNotification (std::string method, std::optional< nlohmann::json > params=std::nullopt) -> asio::awaitable< std::expected< void, RpcError > >
template<typename ParamsType >
auto	SendNotification (std::string method, ParamsType params) -> asio::awaitable< std::expected< void, RpcError > > requires(ToJson< ParamsType > &&NotJsonLike< ParamsType >)
void	RegisterMethodCall (std::string method, typename Dispatcher::MethodCallHandler handler)
template<typename ParamsType , typename ResultType > requires (FromJson<ParamsType> && ToJson<ResultType>)
void	RegisterMethodCall (std::string method, std::function< asio::awaitable< ResultType >(ParamsType)> handler)
template<typename ParamsType , typename ResultType , typename ErrorType > requires (FromJson<ParamsType> && ToJson<ResultType> && ToJson<ErrorType>)
void	RegisterMethodCall (std::string method, std::function< asio::awaitable< std::expected< ResultType, ErrorType > >(ParamsType)> handler)
void	RegisterNotification (std::string method, typename Dispatcher::NotificationHandler handler)
template<typename ParamsType , typename ErrorType > requires (FromJson<ParamsType> && HasMessageMethod<ErrorType>)
void	RegisterNotification (std::string method, std::function< asio::awaitable< std::expected< void, ErrorType > >(ParamsType)> handler)
auto	HasPendingRequests () const -> bool

Static Public Member Functions
static auto	CreateClient (asio::any_io_executor executor, std::unique_ptr< transport::Transport > transport) -> asio::awaitable< std::expected< std::unique_ptr< RpcEndpoint >, RpcError > >

Detailed Description

Definition at line 26 of file endpoint.hpp.

Constructor & Destructor Documentation

RpcEndpoint() [1/3]

jsonrpc::endpoint::RpcEndpoint::RpcEndpoint ( asio::any_io_executor executor, std::unique_ptr< transport::Transport > transport, std::shared_ptr< spdlog::logger > logger = nullptr )

explicit

Definition at line 16 of file endpoint.cpp.

    : logger_(logger ? logger : spdlog::default_logger()),
      executor_(std::move(executor)),
      transport_(std::move(transport)),
      dispatcher_(executor_, logger_),
      endpoint_strand_(asio::make_strand(executor_)) {
}

RpcEndpoint() [2/3]

jsonrpc::endpoint::RpcEndpoint::RpcEndpoint ( const RpcEndpoint & )

delete

RpcEndpoint() [3/3]

jsonrpc::endpoint::RpcEndpoint::RpcEndpoint ( RpcEndpoint && )

delete

~RpcEndpoint()

jsonrpc::endpoint::RpcEndpoint::~RpcEndpoint ( )

default

Member Function Documentation

CreateClient()

auto jsonrpc::endpoint::RpcEndpoint::CreateClient ( asio::any_io_executor executor, std::unique_ptr< transport::Transport > transport ) -> asio::awaitable<std::expected<std::unique_ptr<RpcEndpoint>, RpcError>>

static

Definition at line 27 of file endpoint.cpp.

                                                                        {
  auto endpoint = std::make_unique<RpcEndpoint>(executor, std::move(transport));
 
  auto start_result = co_await endpoint->Start();
  if (!start_result) {
    co_return std::unexpected(start_result.error());
  }
 
  endpoint->Logger()->debug("Client endpoint initialized");
  co_return endpoint;
}

HasPendingRequests()

auto jsonrpc::endpoint::RpcEndpoint::HasPendingRequests ( ) const -> bool

nodiscard

Definition at line 174 of file endpoint.cpp.

                                                   {
  // This is safe to call without a strand because we're just checking if empty
  return !pending_requests_.empty();
}

IsRunning()

auto jsonrpc::endpoint::RpcEndpoint::IsRunning ( ) const -> bool

inlinenodiscard

Definition at line 51 of file endpoint.hpp.

                                               {
    return is_running_.load();
  }

Logger()

auto jsonrpc::endpoint::RpcEndpoint::Logger ( ) -> std::shared_ptr<spdlog::logger>

inline

Definition at line 55 of file endpoint.hpp.

                                               {
    return logger_;
  }

operator=() [1/2]

auto jsonrpc::endpoint::RpcEndpoint::operator= ( const RpcEndpoint & ) -> RpcEndpoint &=delete

delete

operator=() [2/2]

auto jsonrpc::endpoint::RpcEndpoint::operator= ( RpcEndpoint && ) -> RpcEndpoint &=delete

delete

RegisterMethodCall() [1/3]

template<typename ParamsType , typename ResultType >
requires (FromJson<ParamsType> && ToJson<ResultType>)

void jsonrpc::endpoint::RpcEndpoint::RegisterMethodCall	(	std::string	method,
		std::function< asio::awaitable< ResultType >(ParamsType)>	handler )

Definition at line 206 of file endpoint.hpp.

{
  // Create a handler object and store its function object
  // NOTE: We use a shared_ptr to ensure the handler object stays alive
  // throughout the entire lifetime of any coroutine that might use it. This
  // prevents the use-after-free issues that can occur with lambda captures in
  // coroutines.
  auto typed_handler =
      std::make_shared<TypedMethodHandler<ParamsType, ResultType>>(
          std::move(handler));
 
  // Register a lambda that calls the handler object
  RegisterMethodCall(
      method,
      [handler = std::move(typed_handler)](
          std::optional<nlohmann::json> params) { return (*handler)(params); });
}

RegisterMethodCall() [2/3]

template<typename ParamsType , typename ResultType , typename ErrorType >
requires (FromJson<ParamsType> && ToJson<ResultType> && ToJson<ErrorType>)

void jsonrpc::endpoint::RpcEndpoint::RegisterMethodCall	(	std::string	method,
		std::function< asio::awaitable< std::expected< ResultType, ErrorType > >(ParamsType)>	handler )

Definition at line 228 of file endpoint.hpp.

{
  auto typed_handler =
      std::make_shared<TypedMethodHandler<ParamsType, ResultType, ErrorType>>(
          std::move(handler));
 
  RegisterMethodCall(
      method,
      [handler = std::move(typed_handler)](
          std::optional<nlohmann::json> params) { return (*handler)(params); });
}

RegisterMethodCall() [3/3]

void jsonrpc::endpoint::RpcEndpoint::RegisterMethodCall	(	std::string	method,
		typename Dispatcher::MethodCallHandler	handler )

Definition at line 164 of file endpoint.cpp.

                                                                    {
  dispatcher_.RegisterMethodCall(method, handler);
}

References jsonrpc::endpoint::Dispatcher::RegisterMethodCall().

Here is the call graph for this function:

RegisterNotification() [1/2]

template<typename ParamsType , typename ErrorType >
requires (FromJson<ParamsType> && HasMessageMethod<ErrorType>)

void jsonrpc::endpoint::RpcEndpoint::RegisterNotification	(	std::string	method,
		std::function< asio::awaitable< std::expected< void, ErrorType > >(ParamsType)>	handler )

Definition at line 246 of file endpoint.hpp.

{
  // Create a handler object and store its function object
  // NOTE: Using a class-based approach with shared_ptr ownership guarantees
  // the handler remains valid even when coroutines are suspended and resumed,
  // which is safer than direct lambda captures that may go out of scope.
  auto typed_handler =
      std::make_shared<TypedNotificationHandler<ParamsType, ErrorType>>(
          std::move(handler));
 
  // Register a lambda that calls the handler object
  RegisterNotification(
      method,
      [handler = std::move(typed_handler)](
          std::optional<nlohmann::json> params) { return (*handler)(params); });
}

RegisterNotification() [2/2]

void jsonrpc::endpoint::RpcEndpoint::RegisterNotification	(	std::string	method,
		typename Dispatcher::NotificationHandler	handler )

Definition at line 169 of file endpoint.cpp.

                                                                      {
  dispatcher_.RegisterNotification(method, handler);
}

References jsonrpc::endpoint::Dispatcher::RegisterNotification().

Here is the call graph for this function:

SendMethodCall() [1/2]

template<typename ParamsType , typename ResultType >

auto jsonrpc::endpoint::RpcEndpoint::SendMethodCall	(	std::string	method,
		ParamsType	params ) -> asio::awaitable<std::expected<ResultType, RpcError>> requires( ToJson<ParamsType> && NotJsonLike<ParamsType> && FromJson<ResultType>)

Definition at line 146 of file endpoint.hpp.

{
  spdlog::debug("RpcEndpoint sending typed method call: {}", method);
  nlohmann::json json_params;
  try {
    json_params = params;
  } catch (const nlohmann::json::exception &ex) {
    spdlog::error(
        "RpcEndpoint failed to convert parameters to JSON: {}", ex.what());
    co_return RpcError::UnexpectedFromCode(
        RpcErrorCode::kClientSerializationError,
        "RpcEndpoint failed to convert parameters to JSON: " +
            std::string(ex.what()));
  }
 
  auto result = co_await RpcEndpoint::SendMethodCall(method, json_params);
  if (!result) {
    co_return result;
  }
 
  try {
    co_return result->template get<ResultType>();
  } catch (const nlohmann::json::exception &ex) {
    spdlog::error("RpcEndpoint failed to convert result: {}", ex.what());
    co_return RpcError::UnexpectedFromCode(
        RpcErrorCode::kClientDeserializationError,
        "RpcEndpoint failed to convert result: " + std::string(ex.what()));
  }
}

References SendMethodCall(), and jsonrpc::error::RpcError::UnexpectedFromCode().

Here is the call graph for this function:

SendMethodCall() [2/2]

auto jsonrpc::endpoint::RpcEndpoint::SendMethodCall	(	std::string	method,
		std::optional< nlohmann::json >	params = std::nullopt ) -> asio::awaitable<std::expected<nlohmann::json, RpcError>>

Definition at line 110 of file endpoint.cpp.

                                                          {
  if (!is_running_) {
    co_return RpcError::UnexpectedFromCode(
        RpcErrorCode::kClientError, "RPC endpoint is not running");
  }
 
  auto request_id = GetNextRequestId();
  Request request(method, std::move(params), request_id);
  std::string message = request.ToJson().dump();
 
  Logger()->debug("RpcEndpoint sending message: {}", message.substr(0, 70));
  auto pending_request = std::make_shared<PendingRequest>(endpoint_strand_);
  asio::post(endpoint_strand_, [this, request_id, pending_request] {
    pending_requests_[request_id] = pending_request;
  });
 
  auto send_result = co_await transport_->SendMessage(message);
  if (!send_result) {
    co_return std::unexpected(send_result.error());
  }
 
  auto result = co_await pending_request->GetResult();
  if (result.contains("error")) {
    auto err = result["error"];
    co_return RpcError::UnexpectedFromCode(
        RpcErrorCode::kClientError, err["message"].get<std::string>());
  }
 
  co_return result["result"];
}

References jsonrpc::endpoint::Request::ToJson(), and jsonrpc::error::RpcError::UnexpectedFromCode().

Referenced by SendMethodCall().

Here is the call graph for this function:

Here is the caller graph for this function:

SendNotification() [1/2]

template<typename ParamsType >

auto jsonrpc::endpoint::RpcEndpoint::SendNotification	(	std::string	method,
		ParamsType	params ) -> asio::awaitable<std::expected<void, RpcError>> requires(ToJson<ParamsType> && NotJsonLike<ParamsType>)

Definition at line 180 of file endpoint.hpp.

{
  spdlog::debug("RpcEndpoint sending typed notification: {}", method);
  nlohmann::json json_params;
  try {
    json_params = params;
  } catch (const nlohmann::json::exception &ex) {
    spdlog::error(
        "RpcEndpoint failed to convert notification parameters: {}", ex.what());
    co_return RpcError::UnexpectedFromCode(
        RpcErrorCode::kClientSerializationError,
        "RpcEndpoint failed to convert notification parameters: " +
            std::string(ex.what()));
  }
 
  auto result = co_await RpcEndpoint::SendNotification(method, json_params);
  if (!result) {
    co_return result;
  }
 
  co_return Ok();
}

References SendNotification(), and jsonrpc::error::RpcError::UnexpectedFromCode().

Here is the call graph for this function:

SendNotification() [2/2]

auto jsonrpc::endpoint::RpcEndpoint::SendNotification	(	std::string	method,
		std::optional< nlohmann::json >	params = std::nullopt ) -> asio::awaitable<std::expected<void, RpcError>>

Definition at line 143 of file endpoint.cpp.

                                                  {
  Logger()->debug("RpcEndpoint sending notification: {}", method);
  if (!is_running_) {
    co_return RpcError::UnexpectedFromCode(
        RpcErrorCode::kClientError, "RpcEndpoint is not running");
  }
 
  Request request(method, std::move(params));
  std::string message = request.ToJson().dump();
 
  Logger()->debug("RpcEndpoint sending message: {}", message.substr(0, 70));
  auto send_result = co_await transport_->SendMessage(message);
  if (!send_result) {
    co_return send_result;
  }
 
  co_return std::expected<void, RpcError>{};
}

References jsonrpc::endpoint::Request::ToJson(), and jsonrpc::error::RpcError::UnexpectedFromCode().

Referenced by SendNotification().

Here is the call graph for this function:

Here is the caller graph for this function:

Shutdown()

auto jsonrpc::endpoint::RpcEndpoint::Shutdown

(

)

-> asio::awaitable<std::expected<void, RpcError>>

Definition at line 78 of file endpoint.cpp.

                                                                         {
  if (!is_running_.exchange(false)) {
    co_return std::expected<void, RpcError>{};
  }
 
  co_await asio::post(endpoint_strand_, asio::use_awaitable);
  cancel_signal_.emit(asio::cancellation_type::all);
 
  Logger()->debug("Shutting down RPC endpoint");
 
  // Ensure all operations on the strand complete, including message processing
 
  // Cancel pending requests
  for (auto &[id, request] : pending_requests_) {
    request->Cancel(-32603, "RPC endpoint shutting down");
  }
  pending_requests_.clear();
 
  // Wait for the message loop to complete
  if (message_loop_.valid()) {
    co_await std::move(message_loop_);
  }
 
  // Now close the transport
  auto close_result = co_await transport_->Close();
  if (!close_result) {
    co_return close_result;
  }
 
  co_return Ok();
}

Start()

auto jsonrpc::endpoint::RpcEndpoint::Start

(

)

-> asio::awaitable<std::expected<void, RpcError>>

Definition at line 42 of file endpoint.cpp.

                                                                      {
  Logger()->debug("RpcEndpoint starting");
  if (is_running_.exchange(true)) {
    co_return RpcError::UnexpectedFromCode(
        RpcErrorCode::kClientError, "RPC endpoint is already running");
  }
 
  pending_requests_.clear();
 
  // Start the transport
  auto start_result = co_await transport_->Start();
  if (!start_result) {
    co_return start_result;
  }
 
  // Start message processing on the endpoint strand
  StartMessageProcessing();
 
  // Ensure Start completes before Wait checks is_running_
  co_return std::expected<void, RpcError>{};
}

References jsonrpc::error::RpcError::UnexpectedFromCode().

Here is the call graph for this function:

WaitForShutdown()

auto jsonrpc::endpoint::RpcEndpoint::WaitForShutdown

(

)

-> asio::awaitable<std::expected<void, RpcError>>

Definition at line 64 of file endpoint.cpp.

                                                  {
  // If already shut down, return immediately
  if (!is_running_) {
    co_return std::expected<void, RpcError>{};
  }
 
  if (message_loop_.valid()) {
    co_await std::move(message_loop_);
  }
 
  co_return std::expected<void, RpcError>{};
}

---

The documentation for this class was generated from the following files:

• include/jsonrpc/endpoint/endpoint.hpp
• src/endpoint/endpoint.cpp