jsonrpc::transport::FramedSocketTransport Class Reference

Transport layer using Asio sockets for JSON-RPC communication with framing. More...

#include <framed_socket_transport.hpp>

Inheritance diagram for jsonrpc::transport::FramedSocketTransport:

Collaboration diagram for jsonrpc::transport::FramedSocketTransport:

Public Member Functions
	FramedSocketTransport (const std::string &host, uint16_t port, bool is_server)
void	SendMessage (const std::string &message) override
	Sends a message in string to the transport layer.
auto	ReceiveMessage () -> std::string override
	Receives a message from the transport layer.
Public Member Functions inherited from jsonrpc::transport::SocketTransport
	SocketTransport (const std::string &host, uint16_t port, bool is_server)
	Constructs a SocketTransport.
	~SocketTransport () override
	SocketTransport (const SocketTransport &)=delete
auto	operator= (const SocketTransport &) -> SocketTransport &=delete
	SocketTransport (SocketTransport &&)=delete
auto	operator= (SocketTransport &&) -> SocketTransport &=delete
void	SendMessage (const std::string &message) override
	Sends a message in string to the transport layer.
auto	ReceiveMessage () -> std::string override
	Receives a message from the transport layer.
Public Member Functions inherited from jsonrpc::transport::Transport
	Transport ()=default
virtual	~Transport ()=default
	Transport (const Transport &)=default
auto	operator= (const Transport &) -> Transport &=default
	Transport (Transport &&)=delete
auto	operator= (Transport &&) -> Transport &=delete

Additional Inherited Members
Protected Member Functions inherited from jsonrpc::transport::SocketTransport
auto	GetSocket () -> asio::ip::tcp::socket &
Static Protected Member Functions inherited from jsonrpc::transport::FramedTransport
static void	FrameMessage (std::ostream &output, const std::string &message)
	Constructs a framed message.
static auto	ReadHeadersFromStream (std::istream &input) -> HeaderMap
static auto	ReadContentLengthFromStream (std::istream &input) -> int
static auto	ReadContent (std::istream &input, std::size_t content_length) -> std::string
	Reads content from the input stream based on the content length.
static auto	ReceiveFramedMessage (std::istream &input) -> std::string
	Receives a framed message.
Static Protected Attributes inherited from jsonrpc::transport::FramedTransport
static constexpr const char *	kHeaderDelimiter = "\r\n\r\n"
	The delimiter used to separate headers from the message content.

Detailed Description

Transport layer using Asio sockets for JSON-RPC communication with framing.

Definition at line 17 of file framed_socket_transport.hpp.

Constructor & Destructor Documentation

FramedSocketTransport()

jsonrpc::transport::FramedSocketTransport::FramedSocketTransport	(	const std::string &	host,
		uint16_t	port,
		bool	is_server )

Definition at line 11 of file framed_socket_transport.cpp.

    : SocketTransport(host, port, is_server), FramedTransport() {
  spdlog::info(
      "FramedSocketTransport initialized with host: {} and port: {}", host,
      port);
}

Member Function Documentation

ReceiveMessage()

auto jsonrpc::transport::FramedSocketTransport::ReceiveMessage ( ) -> std::string

overridevirtual

Receives a message from the transport layer.

Returns

The JSON-RPC response as a string.

Implements jsonrpc::transport::Transport.

Definition at line 41 of file framed_socket_transport.cpp.

                                                        {
  asio::streambuf buffer;
  asio::error_code ec;
 
  // Read headers until \r\n\r\n delimiter
  asio::read_until(GetSocket(), buffer, kHeaderDelimiter, ec);
  if (ec) {
    throw std::runtime_error("Failed to read message headers: " + ec.message());
  }
 
  std::istream header_stream(&buffer);
 
  // Extract content length from the headers
  int content_length = ReadContentLengthFromStream(header_stream);
 
  // Calculate how much more content we need to read
  std::size_t remaining_content_length = content_length - buffer.size();
 
  // Read any remaining content directly into the buffer
  if (remaining_content_length > 0) {
    asio::read(GetSocket(), buffer.prepare(remaining_content_length), ec);
    if (ec && ec != asio::error::eof) {
      throw std::runtime_error(
          "Failed to read message content: " + ec.message());
    }
    buffer.commit(remaining_content_length);
  }
 
  // Convert the entire buffer to a string
  std::string content(
      asio::buffers_begin(buffer.data()), asio::buffers_end(buffer.data()));
  return content;
}

SendMessage()

void jsonrpc::transport::FramedSocketTransport::SendMessage ( const std::string & message )

overridevirtual

Sends a message in string to the transport layer.

Parameters

request

The JSON-RPC request as a string.

Implements jsonrpc::transport::Transport.

Definition at line 19 of file framed_socket_transport.cpp.

                                                                {
  try {
    asio::streambuf message_buf;
    std::ostream message_stream(&message_buf);
    FrameMessage(message_stream, message);
 
    asio::error_code ec;
    std::size_t bytes_written =
        asio::write(GetSocket(), message_buf.data(), ec);
 
    if (ec) {
      throw std::runtime_error("Error sending message: " + ec.message());
    }
 
    spdlog::info(
        "FramedSocketTransport sent message with {} bytes", bytes_written);
  } catch (const std::exception &e) {
    spdlog::error("FramedSocketTransport failed to send message: {}", e.what());
    throw;
  }
}

References jsonrpc::transport::FramedTransport::FrameMessage(), and jsonrpc::transport::SocketTransport::GetSocket().

Here is the call graph for this function:

---

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

• include/jsonrpc/transport/framed_socket_transport.hpp
• src/transport/framed_socket_transport.cpp