Merge pull request #14 from StephanKa/feature/protobuf-and-cppzmq

Example for usage of protobuf and cppzmq

Author: StephanKa

.github/workflows/build_cmake.yml

@@ -65,7 +65,7 @@ jobs:
       # We need to source the profile file to make sure conan is in PATH
       run: |
         source ~/.profile
-        cmake $GITHUB_WORKSPACE -DCMAKE_BUILD_TYPE=$BUILD_TYPE -DCPP_STARTER_USE_SML=ON -DCPP_STARTER_USE_BOOST_BEAST=ON -DCPP_STARTER_USE_CROW=ON
+        cmake $GITHUB_WORKSPACE -DCMAKE_BUILD_TYPE=$BUILD_TYPE -DCPP_STARTER_USE_SML=ON -DCPP_STARTER_USE_BOOST_BEAST=ON -DCPP_STARTER_USE_CROW=ON -DCPP_STARTER_USE_CPPZMQ_PROTO=ON
 
     - name: Build
       working-directory: ${{runner.workspace}}/build

cmake/Conan.cmake

@@ -19,6 +19,8 @@ macro(run_conan)
     nlohmann_json/3.10.5
     boost/1.78.0
     crowcpp-crow/1.0+1
+    cppzmq/4.8.1
+    protobuf/3.20.0
     OPTIONS
     ${CONAN_EXTRA_OPTIONS}
     gtest:build_gmock=True

src/CMakeLists.txt

@@ -1,6 +1,7 @@
 OPTION(CPP_STARTER_USE_SML "Enable compilation of SML sample" OFF)
 OPTION(CPP_STARTER_USE_BOOST_BEAST "Enable compilation of boost beast sample" OFF)
 OPTION(CPP_STARTER_USE_CROW "Enable compilation of crow sample" OFF)
+OPTION(CPP_STARTER_USE_CPPZMQ_PROTO "Enable compilation of protobuf and cppzmq sample" OFF)
 
 # SML
 IF(CPP_STARTER_USE_SML)
@@ -20,6 +21,11 @@ IF(CPP_STARTER_USE_CROW)
     ADD_SUBDIRECTORY(crow)
 ENDIF()
 
+# CPPZMQ & Protobuf
+IF(CPP_STARTER_USE_CPPZMQ_PROTO)
+    MESSAGE("Using CPPZMQ & Protobuf")
+    ADD_SUBDIRECTORY(protobuf.cppzmq)
+ENDIF()
 
 # Generic test that uses conan libs
 ADD_EXECUTABLE(intro main.cpp)

src/protobuf.cppzmq/CMakeLists.txt

@@ -0,0 +1,15 @@
+FIND_PACKAGE(Protobuf REQUIRED)
+
+INCLUDE_DIRECTORIES(${Protobuf_INCLUDE_DIRS})
+INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR})
+
+PROTOBUF_GENERATE_CPP(PROTO_SRCS PROTO_HDRS ${PROTO_SRC_DIR} proto/event.proto)
+
+ADD_EXECUTABLE(test_cppzmq_proto_server server/main.cpp ${PROTO_SRCS} ${PROTO_HDRS})
+ADD_EXECUTABLE(test_cppzmq_proto_client client/main.cpp ${PROTO_SRCS} ${PROTO_HDRS})
+
+TARGET_INCLUDE_DIRECTORIES(test_cppzmq_proto_server PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/common)
+TARGET_INCLUDE_DIRECTORIES(test_cppzmq_proto_client PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/common)
+
+TARGET_LINK_LIBRARIES(test_cppzmq_proto_server PRIVATE CONAN_PKG::spdlog CONAN_PKG::cppzmq CONAN_PKG::protobuf CONAN_PKG::spdlog)
+TARGET_LINK_LIBRARIES(test_cppzmq_proto_client PRIVATE CONAN_PKG::spdlog CONAN_PKG::cppzmq CONAN_PKG::protobuf CONAN_PKG::spdlog)

src/protobuf.cppzmq/client/main.cpp

@@ -0,0 +1,38 @@
+#include "event.pb.h"
+#include <include/common.h>
+#include <spdlog/spdlog.h>
+#include <string>
+#include <zmq.hpp>
+
+int main()
+{
+    // initialize the zmq context with a single IO thread
+    zmq::context_t context{ 1 };
+
+    // construct a REQ (request) socket and connect to interface
+    zmq::socket_t socket{ context, zmq::socket_type::req };
+    socket.connect("tcp://127.0.0.1:5555");
+
+    // set up some static data to send
+    const std::string senderName{ "Client" };
+
+    zmq::message_t request{};
+    // send the request message
+    auto [sendEvent, serializedData] = Common::prepareMessage(senderName, request);
+
+    for (;;) {
+        // send to the server
+        socket.send(zmq::buffer(serializedData), zmq::send_flags::none);
+
+        // wait for reply from server
+        socket.recv(request, zmq::recv_flags::none);
+        const auto [receivedEvent, _] = Common::prepareMessage(senderName, request);
+        serializedData = Common::incrementPingPong(sendEvent, own::proto::Event::PONG);
+        sendEvent = receivedEvent;
+        Common::logProtoEvent(receivedEvent);
+
+        if (receivedEvent.pong_count() == Common::maxCount) { break; }
+    }
+
+    return 0;
+}

src/protobuf.cppzmq/common/include/common.h

@@ -0,0 +1,50 @@
+#include <spdlog/spdlog.h>
+#include <zmq.hpp>
+
+namespace Common {
+constexpr auto maxCount = 10;
+
+std::tuple<own::proto::Event, std::string> prepareMessage(const std::string &senderName, const zmq::message_t &request)
+{
+    own::proto::Event receivedEvent{};
+    std::string data;
+    receivedEvent.ParseFromArray(request.data(), static_cast<int>(request.size()));
+
+    own::proto::Event event{};
+    event.set_sender(senderName);
+    event.SerializeToString(&data);
+    return std::make_tuple(receivedEvent, data);
+}
+
+[[nodiscard]]std::string incrementPingPong(own::proto::Event& event, own::proto::Event_PingPong eventType)
+{
+    switch (eventType) {
+    case own::proto::Event::PING: {
+        event.set_action(own::proto::Event::PING);
+        event.set_ping_count(event.ping_count() + 1);
+        event.set_pong_count(event.pong_count());
+    }
+    case own::proto::Event::PONG: {
+        event.set_action(own::proto::Event::PONG);
+        event.set_ping_count(event.ping_count());
+        event.set_pong_count(event.pong_count() + 1);
+        break;
+    }
+    default: {
+        break;
+    }
+    }
+    std::string data;
+    event.SerializeToString(&data);
+    return data;
+}
+
+void logProtoEvent(const own::proto::Event &receivedEvent)
+{
+    spdlog::info("Received from: {} - Action: {} - Ping count: {} - Pong count: {}",
+      receivedEvent.sender(),
+      own::proto::Event_PingPong_Name(receivedEvent.action()),
+      receivedEvent.ping_count(),
+      receivedEvent.pong_count());
+}
+}// namespace Common

src/protobuf.cppzmq/proto/event.proto

@@ -0,0 +1,15 @@
+syntax = "proto3";
+
+package own.proto;
+
+message Event {
+    enum PingPong {
+        PING = 0;
+        PONG = 1;
+    }
+
+    string sender = 1;
+    PingPong action = 2;
+    int32 ping_count = 3;
+    int32 pong_count = 4;
+}

src/protobuf.cppzmq/server/main.cpp

@@ -0,0 +1,38 @@
+#include "event.pb.h"
+#include <chrono>
+#include <include/common.h>
+#include <thread>
+
+int main()
+{
+    using namespace std::chrono_literals;
+
+    // initialize the zmq context with a single IO thread
+    zmq::context_t context{ 1 };
+
+    // construct a REP (reply) socket and bind to interface
+    zmq::socket_t socket{ context, zmq::socket_type::rep };
+    socket.bind("tcp://*:5555");
+
+    // prepare some static data for responses
+    const std::string senderName{ "Server" };
+
+    zmq::message_t request{};
+    for (;;) {
+        // receive a request from client
+        socket.recv(request, zmq::recv_flags::none);
+        // simulate work
+        std::this_thread::sleep_for(500ms);
+
+        auto [receivedEvent, serializedData] = Common::prepareMessage(senderName, request);
+        serializedData = Common::incrementPingPong(receivedEvent, own::proto::Event::PING);
+        Common::logProtoEvent(receivedEvent);
+
+          // send the reply to the client
+        socket.send(zmq::buffer(serializedData), zmq::send_flags::none);
+
+        if (receivedEvent.ping_count() == Common::maxCount) { break; }
+    }
+
+    return 0;
+}