jsonrpc::transport::FramedPipeTransport Class Reference

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

#include <framed_pipe_transport.hpp>

Inheritance diagram for jsonrpc::transport::FramedPipeTransport:

Collaboration diagram for jsonrpc::transport::FramedPipeTransport:

Public Member Functions
	FramedPipeTransport (const std::string &socket_path, 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::PipeTransport
	PipeTransport (const std::string &socket_path, bool is_server)
	Constructs a PipeTransport.
	~PipeTransport () override
	PipeTransport (const PipeTransport &)=delete
auto	operator= (const PipeTransport &) -> PipeTransport &=delete
	PipeTransport (PipeTransport &&)=delete
auto	operator= (PipeTransport &&) -> PipeTransport &=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::PipeTransport
auto	GetSocket () -> asio::local::stream_protocol::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 Unix domain sockets for JSON-RPC communication with framing.

Definition at line 16 of file framed_pipe_transport.hpp.

Constructor & Destructor Documentation

FramedPipeTransport()

jsonrpc::transport::FramedPipeTransport::FramedPipeTransport	(	const std::string &	socket_path,
		bool	is_server )

Definition at line 10 of file framed_pipe_transport.cpp.

    : PipeTransport(socket_path, is_server) {
  spdlog::info(
      "FramedPipeTransport initialized with socket path: {}", socket_path);
}

Member Function Documentation

ReceiveMessage()

auto jsonrpc::transport::FramedPipeTransport::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 39 of file framed_pipe_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::FramedPipeTransport::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 17 of file framed_pipe_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(
        "FramedPipeTransport sent message with {} bytes", bytes_written);
  } catch (const std::exception &e) {
    spdlog::error("FramedPipeTransport failed to send message: {}", e.what());
    throw;
  }
}

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

Here is the call graph for this function:

---

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

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