working commit

works/rpcvar/service_test.cpp

@@ -0,0 +1,115 @@
+
+
+#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;
+        }
+}