Олег Бородин
116 lines
3.3 KiB
C++
116 lines
3.3 KiB
C++
|
|
|
|
#include <expected>
|
|
#include <string>
|
|
#include <cstring>
|
|
#include <iostream>
|
|
|
|
#include <control.pb.h>
|
|
|
|
#include <rpcclient.hpp>
|
|
#include <abrpchandler.hpp>
|
|
#include <service.hpp>
|
|
#include <logger.hpp>
|
|
#include <msgheader.hpp>
|
|
|
|
|
|
class TestRPCHandler : public AbstractRPCHandler {
|
|
public:
|
|
std::expected<void, std::string> Handle(std::string& req, std::string& res) override;
|
|
};
|
|
|
|
std::expected<void, std::string> TestRPCHandler::Handle(std::string& rawReq, std::string& rawRes) {
|
|
control::HelloRequest pbReq;
|
|
pbReq.ParseFromString(rawReq);
|
|
logger.Log(std::format("rpcName: {}", pbReq.meta().kind()));
|
|
logger.Log(std::format("req message: {}", pbReq.message()));
|
|
|
|
control::HelloResult pbRes;
|
|
pbRes.set_message("Johnny!");
|
|
logger.Log(std::format("res message: {}", pbRes.message()));
|
|
|
|
auto resMeta = pbRes.mutable_meta();
|
|
resMeta->set_error(false);
|
|
pbRes.SerializeToString(&rawRes);
|
|
return {};
|
|
}
|
|
|
|
|
|
|
|
class TestSocketHandler : public SocketHandler {
|
|
private:
|
|
AbstractRPCHandler* nextHandler;
|
|
public:
|
|
TestSocketHandler(AbstractRPCHandler& rcpHandler);
|
|
virtual void Handle(int sock) override;
|
|
virtual ~TestSocketHandler(void) override;
|
|
};
|
|
|
|
TestSocketHandler::TestSocketHandler(AbstractRPCHandler& rpcHandler) {
|
|
nextHandler = &rpcHandler;
|
|
}
|
|
|
|
TestSocketHandler::~TestSocketHandler(void) {};
|
|
|
|
|
|
void TestSocketHandler::Handle(int sock) {
|
|
logger.Log(std::format("Handler {} start", sock));
|
|
|
|
const int headerSize = rpcHeaderSize;
|
|
std::string inRawHeader(headerSize, '\0');
|
|
int rsize = 0;
|
|
if ((rsize = read(sock, inRawHeader.data(), inRawHeader.size())) < 0) {
|
|
logger.Log("Error read");
|
|
close(sock);
|
|
return;
|
|
}
|
|
logger.Log(std::format("header read size {}", rsize));
|
|
|
|
MessageHeader inHeader;
|
|
inHeader.Decode(inRawHeader);
|
|
int inPacketSize = inHeader.PacketSize();
|
|
logger.Log(std::format("rpc packet size {}", inPacketSize));
|
|
|
|
std::string inRawRequest(inPacketSize, '\0');
|
|
if ((rsize = read(sock, inRawRequest.data(), inRawRequest.size())) < 0) {
|
|
logger.Log("Error read");
|
|
close(sock);
|
|
return;
|
|
}
|
|
logger.Log(std::format("rpc packet rsize {}", rsize));
|
|
|
|
std::string outRawResult;
|
|
nextHandler->Handle(inRawRequest, outRawResult);
|
|
|
|
MessageHeader outHeader(outRawResult.size());
|
|
auto rawPacket = outHeader.Encode();
|
|
rawPacket.append(outRawResult);
|
|
|
|
int wsize = 0;
|
|
if ((wsize = write(sock, rawPacket.data(), rawPacket.size())) < 0) {
|
|
logger.Log("Error write");
|
|
close(sock);
|
|
return;
|
|
}
|
|
|
|
logger.Log(std::format("Handler {} done", sock));
|
|
close(sock);
|
|
}
|
|
|
|
int main(int argc, char** argv) {
|
|
Service svc(1025);
|
|
auto bindres = svc.Bind();
|
|
if (!bindres) {
|
|
std::cerr << bindres.error() << std::endl;
|
|
return 1;
|
|
}
|
|
|
|
TestRPCHandler rcpHandler;
|
|
TestSocketHandler socketHandler(rcpHandler);
|
|
auto listres = svc.Listen(&socketHandler);
|
|
if (!listres) {
|
|
std::cerr << listres.error() << std::endl;
|
|
return 1;
|
|
}
|
|
}
|