rpc_core

a tiny c++11 rpc library, supports all platforms (macOS, Linux, Windows, iOS, Android, etc.) and most microchips ( Arduino, STM32, ESP32/ESP8266, etc.)

Introduction

The complete rpc frameworks (such as gRPC and brpc) have complex functions and are not practical on embedded platforms.

This project offers a lightweight and user-friendly rpc library that is better suited for one-to-one rpc calls. It supports all platforms and a wide range of microchips, including Arduino, STM32, ESP32/ESP8266, and more.

Note: This project solely offers the protocol layer and API, and does not include the implementation of the transport layer. For TCP-based implementations: asio_net

Features

Header-Only
No-Schema
Support performance-limited platforms including microchips
Support any connection type (tcp socket, serial port, etc.)
High Performance Serialization, support most STL containers and user type
Serialization plugins implementations for flatbuffers and nlohmann::json
RAII-based dispose for automatic cancel request
Timeout and Retry API
Support std::future interface

Requirements

C++11
Provide your connection implementation: connection
NOTICE: complete data packets are required for data transmission, such as websocket.
If using tcp socket, serial port, etc., message pack and unpack need to be implemented. Or you can use stream_connection.

Usage

// The Receiver
rpc->subscribe("cmd", [](const std::string& msg) -> std::string {
    assert(msg == "hello");
    return "world";
});

// The Sender
rpc->cmd("cmd")
    ->msg(std::string("hello"))
    ->rsp([](const std::string& rsp) {
      assert(rsp == "world");
    })
    ->call();

msg and rsp support any serializable type, see Serialization.

Detailed usages and unittests can be found here: rpc_test.cpp

Serialization

High-performance and memory-saving binary serialization.

For example, user data:

struct Type {
  uint8_t id = 1;
  uint8_t age = 18;
  std::string name = "test";
};

json: {"id":1,"age":18,"name":"test"}

library	bytes
json	31
flatbuffers	44
protobuf	10
msgpack	8
rpc_core	8

std::string
std::wstring
std::array
std::vector
std::list
std::forward_list
std::deque
std::pair
std::tuple
std::map
std::unordered_map
std::multimap
std::unordered_multimap
std::set
std::unordered_set
std::multiset
std::unordered_multiset
std::stack
std::queue
std::priority_queue
std::bitset
std::complex
std::chrono::duration
std::chrono::time_point
std::unique_ptr
std::shared_ptr
rpc_core::binary_wrap

custom struct/class

#include "rpc_core/serialize.hpp"
struct TestStruct {
  uint8_t a;
  std::string b;
  OtherType c
  // RPC_CORE_DEFINE_TYPE_INNER(a, b, c);
};
RPC_CORE_DEFINE_TYPE(TestStruct, a, b, c);

choose RPC_CORE_DEFINE_TYPE or RPC_CORE_DEFINE_TYPE_INNER for private member variable.

Serialization Plugins

flatbuffers.hpp
Supports using types generated by flatbuffers directly as message
(add the option --gen-object-api when using flatc)
json_msg.hpp
Supports using types supported by nlohmann/json directly as message
(the to_json/from_json rules in nlohmann/json need to be satisfied, and use DEFINE_JSON_CLASS).
json.hpp
A flexible way to use nlohmann/json

5.7 KiB Raw Blame History