florian/mesytec-mnode
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

work on rpc

Browse source
This commit is contained in:
Florian Lüke 2024-12-12 00:31:03 +01:00
parent bf03a19820
commit 17787b8ab1
8 changed files with 189 additions and 77 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
external/mesytec-mvlc vendored

@ -1 +1 @@
Subproject commit 31606b39eab4b3581633d6693329082328ff7c62
Subproject commit 3347a186c7c3eb0a12b6baa76b90e71d573fcd39

4
include/mesytec-mnode/mnode_cpp_types.h
View file

@ -3,9 +3,10 @@
#include <cstdint>
namespace mesytec::mnode::cpp_types
namespace mesytec::mnode
{
// clang-format off
using u8 = std::uint8_t;
using u16 = std::uint16_t;
using u32 = std::uint32_t;
@ -15,6 +16,7 @@ using s8 = std::int8_t;
using s16 = std::int16_t;
using s32 = std::int32_t;
using s64 = std::int64_t;
// clang-format on
} // namespace mesytec::mnode::cpp_types

16
include/mesytec-mnode/mnode_nng_proto.h Normal file
View file

@ -0,0 +1,16 @@
#ifndef D9BA34A9_3472_4E22_8E82_5C335EDA67C7
#define D9BA34A9_3472_4E22_8E82_5C335EDA67C7
#include <google/protobuf/message_lite.h>
#include <nng/nng.h>
namespace mesytec::mnode::nng
{
size_t serialize_proto_to_nng(const google::protobuf::MessageLite &message, nng_msg *msg);
size_t deserialize_proto_from_nng(google::protobuf::MessageLite &message, nng_msg *msg);
size_t deserialize_proto_from_nng_trim(google::protobuf::MessageLite &message, nng_msg *msg);
} // namespace mesytec::mnode::nng
#endif /* D9BA34A9_3472_4E22_8E82_5C335EDA67C7 */

4
proto/mrpc.proto
View file

@ -7,13 +7,17 @@ package mesytec.mnode.proto.mrpc;
message MethodCall
{
// Service::GetDescriptor()->full_name()
string service = 1;
// MethodDescriptor::full_name()
string method = 2;
// Must be of type Service::GetRequestPrototype(method)
google.protobuf.Any request = 3;
}
message MethodCallResponse
{
google.rpc.Status status = 1;
// Is of type Service::GetResponsePrototype(method)
google.protobuf.Any response = 2;
}

4
src/CMakeLists.txt
View file

@ -6,11 +6,11 @@ set(MVLC_NNG_MNODE_WARN_FLAGS -Wall -Wextra -Wpedantic)
# set(CMAKE_CXX_CLANG_TIDY clang-tidy -p ${CMAKE_BINARY_DIR} --extra-arg=-std=c++17)
#endif()
add_library(mesytec-mnode mnode_nng.cc mnode_nng_async.cc)
add_library(mesytec-mnode mnode_nng.cc mnode_nng_async.cc mnode_nng_proto.cc)
target_include_directories(mesytec-mnode
PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/../include>
PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/mesytec-mnode)
target_link_libraries(mesytec-mnode PUBLIC nng PRIVATE spdlog)
target_link_libraries(mesytec-mnode PUBLIC nng mnode-proto PRIVATE spdlog)
target_compile_features(mesytec-mnode PRIVATE cxx_std_17)
add_library(mesytec-mnode-dev INTERFACE)

57
src/mnode_nng_proto.cc Normal file
View file

@ -0,0 +1,57 @@
#include <mesytec-mnode/mnode_nng_proto.h>
#include <mesytec-mnode/mnode_nng.h>
#include <mesytec-mnode/mnode_cpp_types.h>
namespace mesytec::mnode::nng
{
size_t serialize_proto_to_nng(const google::protobuf::MessageLite &message, nng_msg *msg)
{
auto messageSize = message.ByteSizeLong();
if (auto res = nng_msg_realloc(msg, nng_msg_len(msg) + sizeof(u32) + messageSize))
return false;
*reinterpret_cast<u32 *>(nng_msg_body(msg)) = messageSize;
if (!message.SerializeToArray(reinterpret_cast<u8 *>(nng_msg_body(msg)) + sizeof(u32),
messageSize))
{
return 0;
}
return sizeof(u32) + messageSize;
}
size_t deserialize_proto_from_nng(google::protobuf::MessageLite &message, nng_msg *msg)
{
if (nng_msg_len(msg) < sizeof(u32))
return 0;
auto messageSize = *reinterpret_cast<u32 *>(nng_msg_body(msg));
if (messageSize == 0)
return 0;
if (nng_msg_len(msg) < sizeof(u32) + messageSize)
return 0;
if (!message.ParseFromArray(reinterpret_cast<u8 *>(nng_msg_body(msg)) + sizeof(u32),
messageSize))
{
return 0;
}
return sizeof(u32) + messageSize;
}
size_t deserialize_proto_from_nng_trim(google::protobuf::MessageLite &message, nng_msg *msg)
{
if (auto result = deserialize_proto_from_nng(message, msg))
{
nng_msg_trim(msg, result);
return result;
}
return 0;
}
} // namespace mesytec::mnode::nng

118
src/mnode_proto_rpc_ping_client.cc
View file

@ -2,8 +2,9 @@
#include <mesytec-mvlc/mesytec-mvlc.h>
#include <mesytec-mvlc/util/signal_handling.h>
#include <mesytec-mnode/mnode_nng_async.h>
#include <mesytec-mnode/mnode_cpp_types.h>
#include <mesytec-mnode/mnode_nng_async.h>
#include <mesytec-mnode/mnode_nng_proto.h>
#include "internal/argh.h"
#include "proto/google/rpc/code.pb.h"
#include "proto/mrpc.pb.h"
@ -12,39 +13,7 @@
using namespace mesytec;
using namespace std::literals;
using namespace mesytec::mnode::cpp_types;
class MVLCService: public mnode::proto::mvlc::MVLCService
{
public:
explicit MVLCService(mesytec::mvlc::MVLC mvlc)
: mvlc_(mvlc)
{ }
void ReadRegister(::google::protobuf::RpcController *controller,
const mnode::proto::mvlc::ReadRegisterRequest *request,
mnode::proto::mvlc::ReadRegisterResponse *response,
::google::protobuf::Closure *done) override
{
spdlog::info("MVLCService::ReadRegister");
u32 value;
if (auto ec = mvlc_.readRegister(request->address(), value))
{
response->mutable_status()->set_code(ec.value());
response->mutable_status()->set_message(ec.message());
controller->SetFailed(ec.message());
}
else
{
response->set_value(value);
}
done->Run();
}
private:
mesytec::mvlc::MVLC mvlc_;
};
using namespace mesytec::mnode;
void print_service_descriptors(google::protobuf::Service &service)
{
@ -62,20 +31,32 @@ void print_service_descriptors(google::protobuf::Service &service)
}
}
struct RPCClosure: public google::protobuf::Closure
struct RpcClosure: public google::protobuf::Closure
{
void Run() override { }
};
struct RPCController: public google::protobuf::RpcController
struct RpcController: public google::protobuf::RpcController
{
void Reset() override { }
bool Failed() const override { return false; }
std::string ErrorText() const override { return ""; }
void Reset() override
{
failed_ = false;
canceled_ = false;
errorText_.clear();
cancelCallback_ = nullptr;
}
bool Failed() const override { return failed_; }
std::string ErrorText() const override { return errorText_; }
void StartCancel() override { }
void SetFailed(const std::string &reason) override { }
bool IsCanceled() const override { return false; }
void NotifyOnCancel(google::protobuf::Closure *callback) override { }
void SetFailed(const std::string &reason) override { errorText_ = reason; failed_ = true; }
bool IsCanceled() const override { return canceled_; }
void NotifyOnCancel(google::protobuf::Closure *callback) override { cancelCallback_ = callback; }
bool failed_ = false;
bool canceled_ = false;
std::string errorText_;
google::protobuf::Closure *cancelCallback_ = nullptr;
};
struct RpcChannel: public google::protobuf::RpcChannel
@ -85,17 +66,12 @@ struct RpcChannel: public google::protobuf::RpcChannel
{
}
int send_request(const mnode::proto::mrpc::MethodCall &methodCall)
void fail(google::protobuf::RpcController *controller, const std::string &reason, google::rpc::Code code)
{
auto methodCallSize = methodCall.ByteSizeLong();
auto msg = mnode::nng::allocate_message(sizeof(u32) + methodCallSize);
*reinterpret_cast<u32 *>(nng_msg_body(msg.get())) = methodCallSize;
if (!methodCall.SerializeToArray(reinterpret_cast<u8 *>(nng_msg_body(msg.get())) + sizeof(u32), methodCallSize))
{
spdlog::error("methodCall.SerializeToArray failed");
}
spdlog::info("sending request: nng_msg_len={}, methodCallSize={}", nng_msg_len(msg.get()), methodCallSize);
return mnode::nng::send_message(socket_, msg);
controller->SetFailed(reason);
callResponse_.mutable_status()->set_code(code);
callResponse_.mutable_status()->set_message(reason);
callResponse_.mutable_status()->clear_details();
}
void CallMethod(const google::protobuf::MethodDescriptor *method,
@ -109,9 +85,25 @@ struct RpcChannel: public google::protobuf::RpcChannel
methodCall_.set_service(method->service()->full_name());
methodCall_.set_method(method->full_name());
methodCall_.mutable_request()->PackFrom(*request);
if (auto nng_res = send_request(methodCall_))
if (!methodCall_.mutable_request()->PackFrom(*request))
{
fail(controller, "PackFrom failed", google::rpc::Code::INTERNAL);
spdlog::error("PackFrom failed");
return;
}
auto msg = mnode::nng::allocate_message(0);
if (mnode::nng::serialize_proto_to_nng(methodCall_, msg.get()) == 0)
{
spdlog::error("serialize_proto_to_nng failed");
return;
}
spdlog::info("sending request: nng_msg_len={}", nng_msg_len(msg.get()));
if (auto nng_res = mnode::nng::send_message(socket_, msg))
{
spdlog::error("nng_sendmsg: {}", nng_strerror(nng_res));
return;
@ -130,7 +122,19 @@ struct RpcChannel: public google::protobuf::RpcChannel
return;
}
auto callResponseSize = mnode::nng::msg_trim_read<u32>(nng_response.get());
if (mnode::nng::deserialize_proto_from_nng_trim(callResponse_, nng_response.get()) == 0)
{
spdlog::error("deserialize_proto_from_nng_trim failed");
return;
}
if (!callResponse_.response().UnpackTo(response))
{
spdlog::error("UnpackTo failed");
return;
}
done->Run();
}
nng_socket socket_;
@ -151,8 +155,8 @@ int main()
return res;
}
RPCController rpcController;
RPCClosure done;
RpcController rpcController;
RpcClosure done;
RpcChannel rpcChannel(socket);
mnode::proto::mvlc::MVLCService::Stub mvlcService(&rpcChannel);

57
src/mnode_proto_rpc_ping_server.cc
View file

@ -12,7 +12,7 @@
using namespace mesytec;
using namespace std::literals;
using namespace mesytec::mnode::cpp_types;
using namespace mesytec::mnode;
class MVLCService: public mnode::proto::mvlc::MVLCService
{
@ -60,7 +60,7 @@ class MVLCService: public mnode::proto::mvlc::MVLCService
{
std::vector<u32> dest;
ec = mvlc_.vmeBlockRead(request->address(), amod, maxTransfers, dest, fifo);
for (auto d : dest)
for (auto d: dest)
{
response->add_value(d);
}
@ -95,35 +95,31 @@ void print_service_descriptors(google::protobuf::Service &service)
}
}
struct RPCClosure: public google::protobuf::Closure
struct RpcClosure: public google::protobuf::Closure
{
void Run() override {}
};
struct RPCController: public google::protobuf::RpcController
struct RpcController: public google::protobuf::RpcController
{
void Reset() override
{
spdlog::debug("RPCController::Reset");
}
void Reset() override { spdlog::debug("RpcController::Reset"); }
bool Failed() const override { return false; }
std::string ErrorText() const override { return ""; }
void StartCancel() override {}
void SetFailed(const std::string &reason) override
{
spdlog::error("RPCController::SetFailed: reason={}", reason);
spdlog::error("RpcController::SetFailed: reason={}", reason);
}
bool IsCanceled() const override { return false; }
void NotifyOnCancel(google::protobuf::Closure */*callback*/) override {}
void NotifyOnCancel(google::protobuf::Closure * /*callback*/) override {}
};
struct RpcChannel: public google::protobuf::RpcChannel
{
void CallMethod(const google::protobuf::MethodDescriptor *method,
google::protobuf::RpcController *controller,
const google::protobuf::Message *request,
google::protobuf::Message *response,
const google::protobuf::Message *request, google::protobuf::Message *response,
google::protobuf::Closure *done) override
{
spdlog::info("RpcChannel::CallMethod: method={}, request={}, response={}",
@ -131,6 +127,39 @@ struct RpcChannel: public google::protobuf::RpcChannel
}
};
bool serialize_proto_to_nng(const google::protobuf::MessageLite &message, nng_msg *msg)
{
auto messageSize = message.ByteSizeLong();
if (auto res = nng_msg_realloc(msg, nng_msg_len(msg) + sizeof(u32) + messageSize); res != 0)
{
spdlog::error("nng_msg_realloc: {}", nng_strerror(res));
return false;
}
*reinterpret_cast<u32 *>(nng_msg_body(msg)) = messageSize;
return message.SerializeToArray(reinterpret_cast<u8 *>(nng_msg_body(msg)) + sizeof(u32),
messageSize);
}
bool deserialize_proto_from_nng(google::protobuf::MessageLite &message, nng_msg *msg)
{
auto messageSize = mnode::nng::msg_trim_read<u32>(msg);
if (!messageSize)
return false;
if (nng_msg_len(msg) < *messageSize)
{
spdlog::error("message too short");
return false;
}
bool ret = message.ParseFromArray(reinterpret_cast<u8 *>(nng_msg_body(msg)), *messageSize);
nng_msg_trim(msg, *messageSize);
return ret;
}
struct RPCServer
{
explicit RPCServer(nng_socket socket)
@ -268,8 +297,8 @@ struct RPCServer
nng_socket socket_;
std::unordered_map<std::string, google::protobuf::Service *> services_;
std::unordered_map<std::string, const google::protobuf::MethodDescriptor *> methods_;
RPCClosure done_;
RPCController controller_;
RpcClosure done_;
RpcController controller_;
};
int main()