Tutorial Implementing JSON RPC - liuli-neko/NekoProtoTools GitHub Wiki

// NekoProtoTools JSON-RPC
#include <nekoproto/jsonrpc/jsonrpc.hpp>
// Include NekoProtoTools type support for any types used in RPC methods
#include <nekoproto/proto/types/vector.hpp>   // For std::vector example
#include <nekoproto/proto/types/string.hpp>  // For std::string example

// Ilias Library
#include <ilias/platform.hpp>  // For PlatformContext
#include <ilias/task.hpp>        // For ilias::Task, ilias::IoTask, co_await, ilias_go

// Standard Library
#include <numeric> // For std::accumulate in example
#include <iostream>
#include <vector>
#include <string>
#include <cstdint> // For int types if needed

NEKO_USE_NAMESPACE // Use NekoProto namespace
using namespace ILIAS_NAMESPACE; // Use Ilias namespace

// Define the structure grouping our RPC methods
struct CalculatorModule {
    // Method "add": Takes two integers, returns an integer.
    RpcMethod<int(int, int), "add", "num1", "num2"> add;

    // Method "subtract": Takes two integers, returns an integer.
    RpcMethod<int(int, int), "subtract", "num1", "num2"> subtract;

    // Method "sum": Takes a vector of integers, returns an integer.
    // The implementation will be asynchronous (returning ilias::IoTask<int>).
    RpcMethod<int(std::vector<int>), "sum", "nums"> sum;

    // Method "greet": Takes a string, returns a string.
    RpcMethod<std::string(std::string), "greet"> greet;
};

// Server logic as an Ilias coroutine Task
ilias::Task<> run_server(PlatformContext& context) {
    try {
        // Create a JSON-RPC server templated on our module type
        JsonRpcServer<CalculatorModule> rpc_server;

        std::cout << "Server: Binding RPC methods..." << std::endl;

        // --- Bind Implementations ---
        // Use lambdas, function pointers, or std::function.
        // The signature must match the RpcMethod definition.

        // Bind 'add' method
        rpc_server->add = [](int a, int b) -> int {
            std::cout << "Server: add(" << a << ", " << b << ") called." << std::endl;
            return a + b;
        };

        // Bind 'subtract' method
        rpc_server->subtract = [](int a, int b) {
            std::cout << "Server: subtract(" << a << ", " << b << ") called." << std::endl;
            return a - b;
        };

        // Bind 'sum' method (Asynchronous Implementation)
        // The lambda returns an ilias::IoTask<int> matching the expected return type
        // for async operations within the Ilias context.
        rpc_server->sum = [](std::vector<int> vec) -> ilias::IoTask<int> {
            std::cout << "Server: sum(...) called asynchronously." << std::endl;
            // Perform potentially long-running work here...
            // (In this case, it's fast, but demonstrates the concept)
            int result = std::accumulate(vec.begin(), vec.end(), 0);
            // You could 'co_await' other async operations inside here if needed.
            co_return result; // Use co_return for async task results
        };

        // Bind 'greet' method
        rpc_server->greet = [](std::string name) -> std::string {
            std::cout << "Server: greet(\"" << name << "\") called." << std::endl;
            return "Hello, " + name + "!";
        };

        // Start the server listening on a specific address and port
        // The address scheme (e.g., "tcp://") determines the transport.
        std::string listen_address = "tcp://127.0.0.1:12335";
        std::cout << "Server: Starting on " << listen_address << "..." << std::endl;
        auto start_result = co_await rpc_server.start(listen_address);
        if (!start_result) {
            std::cerr << "Server failed to start: " << start_result.error().message() << std::endl;
            co_return;
        }
        std::cout << "RPC Server listening on " << listen_address << std::endl;
        std::cout << "Server: Built-in methods available (e.g., rpc.get_method_list)." << std::endl;

        // Keep the server running until stopped (e.g., by Ctrl+C or another signal)
        co_await rpc_server.wait();
        std::cout << "RPC Server stopped." << std::endl;

    } catch (const std::exception& e) {
        std::cerr << "Server error: " << e.what() << std::endl;
    }
}

// Client logic as an Ilias coroutine Task
ilias::Task<> run_client(PlatformContext& context) {
    try {
        // Create a JSON-RPC client templated on the *same* module type
        JsonRpcClient<CalculatorModule> rpc_client;

        // Connect to the server address
        std::string server_address = "tcp://127.0.0.1:12335";
        std::cout << "Client: Connecting to " << server_address << "..." << std::endl;
        auto connect_result = co_await rpc_client.connect(server_address);
        if (!connect_result) {
            std::cerr << "Client failed to connect: " << connect_result.error().message() << std::endl;
            co_return;
        }
        std::cout << "Client connected to " << server_address << std::endl;

        // --- Call Remote Methods ---
        // Use 'co_await rpc_client->method_name(args...)'
        // The return type is ilias::Result<ExpectedReturnType>

        // Call 'add'
        std::cout << "Client: Calling add(10, 5)..." << std::endl;
        auto add_result = co_await rpc_client->add(10, 5);
        if (add_result) { // Check if the call was successful (no transport or RPC error)
            std::cout << "Client: add(10, 5) = " << add_result.value() << std::endl; // Access result with .value()
        } else {
            // Error occurred (e.g., connection closed, server returned JSON-RPC error)
            std::cerr << "Client: 'add' call failed: " << add_result.error().message() << std::endl;
        }

        // Call 'sum' (which is implemented asynchronously on the server)
        std::cout << "Client: Calling sum({1, 2, 3, 4, 5})..." << std::endl;
        std::vector<int> nums = {1, 2, 3, 4, 5};
        auto sum_result = co_await rpc_client->sum(nums);
        if (sum_result) {
            std::cout << "Client: sum({1,2,3,4,5}) = " << sum_result.value() << std::endl;
        } else {
            std::cerr << "Client: 'sum' call failed: " << sum_result.error().message() << std::endl;
        }

        // Call 'greet'
        std::cout << "Client: Calling greet(\"Neko\")..." << std::endl;
        auto greet_result = co_await rpc_client->greet("Neko");
        if (greet_result) {
            std::cout << "Client: greet(\"Neko\") = \"" << greet_result.value() << "\"" << std::endl;
        } else {
            std::cerr << "Client: 'greet' call failed: " << greet_result.error().message() << std::endl;
        }

        // --- Calling a non-existent method (Example of compile-time safety) ---
        // If you uncomment the following line, it will *fail to compile* because
        // 'multiply' is not defined in CalculatorModule.
        // auto multiply_result = co_await rpc_client->multiply(2, 3);

        // Close the connection
        rpc_client.close();
        std::cout << "Client disconnected." << std::endl;

    } catch (const std::exception& e) {
        std::cerr << "Client error: " << e.what() << std::endl;
    }
}

int main() {
    PlatformContext context; // Ilias event loop and execution context

    std::cout << "Starting JSON-RPC server and client tasks..." << std::endl;

    // Launch the server coroutine
    ilias_go run_server(context);

    // Launch the client coroutine (give server a moment to start)
    // In a real app, you might add retry logic or wait for a signal
    ilias_go run_client(context);

    // Run the Ilias event loop until all tasks complete
    context.run();

    std::cout << "All tasks finished." << std::endl;
    // Note: In this simple example, the server might not shut down gracefully
    // unless interrupted (Ctrl+C). Real applications need proper shutdown mechanisms.
    return 0;
}