Replace protobuf with JSON

CMakeLists.txt

@@ -10,7 +10,7 @@ INCLUDE(CheckPIESupported)
 CHECK_PIE_SUPPORTED()
 SET(CMAKE_POSITION_INDEPENDENT_CODE ON)
 
-SET(MISSION_MODULE_VERSION 1.2.11)
+SET(MISSION_MODULE_VERSION 2.0.0)
 
 OPTION(BRINGAUTO_INSTALL "Configure install" OFF)
 OPTION(BRINGAUTO_PACKAGE "Configure package creation" OFF)
@@ -54,12 +54,13 @@ IF (NOT BRINGAUTO_SYSTEM_DEP)
     ENDIF ()
 ENDIF ()
 
+FIND_PACKAGE(nlohmann_json 3.10.5 REQUIRED)
 FIND_PACKAGE(Protobuf 3.21.12 REQUIRED)
 FIND_PACKAGE(fleet-protocol-interface 2.0.0 REQUIRED)
 FIND_PACKAGE(fleet-protocol-cxx-helpers-static 1.1.1 REQUIRED)
 
 IF (FLEET_PROTOCOL_BUILD_EXTERNAL_SERVER)
-    FIND_PACKAGE(fleet-http-client-shared 1.5.0 REQUIRED)
+    FIND_PACKAGE(fleet-http-client-shared 2.0.0 REQUIRED)
     ### fleet-http-client dependencies
     FIND_PACKAGE(Boost REQUIRED)
     FIND_PACKAGE(cpprestsdk REQUIRED)
@@ -71,18 +72,18 @@ CMDEF_ADD_LIBRARY(
         VERSION ${MISSION_MODULE_VERSION}
 )
 
-# Protobuf mission payload
+# Protobuf, JSON mission payload
 SET(Protobuf_USE_STATIC_LIBS ON)
 FILE(GLOB_RECURSE protobuf_mission_cpp_files "lib/protobuf-mission-module/*")
-ADD_LIBRARY(protobuf_mission_lib STATIC ${protobuf_mission_cpp_files})
-TARGET_INCLUDE_DIRECTORIES(protobuf_mission_lib PUBLIC "lib/protobuf-mission-module/")
-TARGET_LINK_LIBRARIES(protobuf_mission_lib PUBLIC protobuf::libprotobuf)
+ADD_LIBRARY(message_handler_lib STATIC ${protobuf_mission_cpp_files})
+TARGET_INCLUDE_DIRECTORIES(message_handler_lib PUBLIC "lib/protobuf-mission-module/")
+TARGET_LINK_LIBRARIES(message_handler_lib PUBLIC protobuf::libprotobuf nlohmann_json::nlohmann_json)
 
 FILE(GLOB_RECURSE HEADERS "include/*")
 
 ADD_LIBRARY(mission_module_hpp INTERFACE ${HEADERS})
 TARGET_INCLUDE_DIRECTORIES(mission_module_hpp INTERFACE "include/")
-TARGET_LINK_LIBRARIES(mission_module_hpp INTERFACE protobuf_mission_lib)
+TARGET_LINK_LIBRARIES(mission_module_hpp INTERFACE message_handler_lib)
 
 FILE(GLOB_RECURSE SOURCES "source/bringauto/*")
 
@@ -92,7 +93,7 @@ TARGET_LINK_LIBRARIES(mission_module_sources PUBLIC
         mission_module_hpp
         fleet-protocol-interface::common-headers-interface
         fleet-protocol-cxx-helpers-static::fleet-protocol-cxx-helpers-static
-        protobuf_mission_lib
+        message_handler_lib
 )
 
 IF (FLEET_PROTOCOL_BUILD_MODULE_GATEWAY)

cmake/Dependencies.cmake

@@ -1,12 +1,13 @@
 SET(CMAKE_FIND_USE_CMAKE_SYSTEM_PATH FALSE)
 
-BA_PACKAGE_LIBRARY(fleet-protocol-interface             v2.0.0 PLATFORM_STRING_MODE any_machine NO_DEBUG ON)
-BA_PACKAGE_LIBRARY(fleet-protocol-cxx-helpers-static    v1.1.1)
-BA_PACKAGE_LIBRARY(protobuf      v4.21.12)
-BA_PACKAGE_LIBRARY(zlib          v1.2.11)
+BA_PACKAGE_LIBRARY(fleet-protocol-interface          v2.0.0 PLATFORM_STRING_MODE any_machine NO_DEBUG ON)
+BA_PACKAGE_LIBRARY(fleet-protocol-cxx-helpers-static v1.1.1)
+BA_PACKAGE_LIBRARY(zlib                              v1.2.11)
+BA_PACKAGE_LIBRARY(nlohmann-json                     v3.10.5 PLATFORM_STRING_MODE any_machine NO_DEBUG ON)
+BA_PACKAGE_LIBRARY(protobuf                          v4.21.12)
 
 IF (FLEET_PROTOCOL_BUILD_EXTERNAL_SERVER)
-    BA_PACKAGE_LIBRARY(fleet-http-client-shared v1.5.0)
+    BA_PACKAGE_LIBRARY(fleet-http-client-shared v2.0.0)
     BA_PACKAGE_LIBRARY(boost                    v1.86.0)
     BA_PACKAGE_LIBRARY(cpprestsdk               v2.10.20)
 ENDIF ()

include/bringauto/ba_json/JsonHelper.hpp

@@ -0,0 +1,26 @@
+#pragma once
+
+#include <fleet_protocol/common_headers/memory_management.h>
+
+#include <MissionModule.pb.h>
+
+#include <nlohmann/json.hpp>
+
+namespace bringauto::ba_json {
+
+using json = nlohmann::ordered_json;
+
+class JsonHelper {
+public:
+	static int bufferToJson(json& json, const buffer& buffer);
+
+	static int jsonToBuffer(buffer* buffer, const json& json);
+
+	static MissionModule::AutonomyStatus_State stringToAutonomyState(const std::string_view &state);
+
+	static std::string autonomyStateToString(MissionModule::AutonomyStatus_State state);
+
+	static std::string autonomyActionToString(MissionModule::AutonomyCommand_Action action);
+
+};
+}

include/bringauto/modules/mission_module/Constants.hpp

@@ -18,7 +18,7 @@ class Constants {
     /**
      * @brief Minimum time between two status messages being sent when speed is above the threshold
      */
-    static constexpr std::chrono::milliseconds status_sending_period = std::chrono::milliseconds(2900);
+    static constexpr auto status_sending_period = std::chrono::milliseconds(2900);
 };
 
-}
+}

include/bringauto/modules/mission_module/Context.hpp

@@ -5,14 +5,13 @@
 
 #include <vector>
 #include <condition_variable>
-#include <thread>
 
 namespace bringauto::modules::mission_module {
 
 struct Context {
-    std::shared_ptr<bringauto::fleet_protocol::http_client::FleetApiClient> fleet_api_client;
+    std::shared_ptr<fleet_protocol::http_client::FleetApiClient> fleet_api_client;
     std::vector<device_identification> devices;
-    std::vector<std::pair<std::string, bringauto::fleet_protocol::cxx::DeviceID>> command_vector;
+    std::vector<std::pair<std::string, fleet_protocol::cxx::DeviceID>> command_vector;
     std::mutex mutex;
     std::condition_variable con_variable;
     long last_command_timestamp;

include/bringauto/modules/mission_module/MissionModule.hpp

@@ -2,7 +2,7 @@
 
 
 namespace bringauto::modules::mission_module {
-	static const int MISSION_MODULE_NUMBER = 1;
+	static constexpr int MISSION_MODULE_NUMBER = 1;
 
-	static const int AUTONOMY_DEVICE_TYPE = 1;
-}
+	static constexpr int AUTONOMY_DEVICE_TYPE = 1;
+}

include/bringauto/modules/mission_module/devices/AutonomyDevice.hpp

@@ -1,8 +1,8 @@
 #pragma once
 
-#include <MissionModule.pb.h>
 #include <fleet_protocol/common_headers/memory_management.h>
 
+#include <chrono>
 #include <map>
 
 namespace bringauto::modules::mission_module::devices {
@@ -90,13 +90,10 @@ class AutonomyDevice {
 	 */
 	static int command_data_valid(const struct buffer command);
 private:
-	static MissionModule::AutonomyCommand generateCommand(std::vector<MissionModule::Station> stops, std::string route,
-														  MissionModule::AutonomyCommand::Action action);
-
 	/**
 	 * @brief Map of last sent status timestamps for each device type
 	 */
 	static std::map<unsigned int, std::chrono::milliseconds> last_sent_status_timestamps_;
 
 };
-}
+}

include/bringauto/protobuf/ProtobufHelper.hpp

@@ -8,12 +8,12 @@ class ProtobufHelper {
 public:
 	static int serializeProtobufMessageToBuffer(struct buffer* message, const google::protobuf::Message &protobufMessage);
 
-	static MissionModule::AutonomyStatus parseAutonomyStatus(struct buffer status);
+	static int validateAutonomyStatus(const std::string &status);
 
-	static MissionModule::AutonomyCommand parseAutonomyCommand(struct buffer command);
+	static int validateAutonomyCommand(const std::string &command);
 
-	static MissionModule::AutonomyError parseAutonomyError(struct buffer errorMessage);
+	static int validateAutonomyError(const std::string &errorMessage);
 
 
 };
-}
+}

source/bringauto/ba_json/JsonHelper.cpp

@@ -0,0 +1,70 @@
+#include <fleet_protocol/common_headers/general_error_codes.h>
+
+#include <bringauto/ba_json/JsonHelper.hpp>
+
+
+namespace bringauto::ba_json {
+
+using json = nlohmann::ordered_json;
+
+int JsonHelper::bufferToJson(json& json, const buffer& buffer) {
+    const auto buffer_data = static_cast<char*> (buffer.data);
+    try {
+        json = json::parse(buffer_data, buffer_data + buffer.size_in_bytes);
+    } catch (json::parse_error &) {
+        return NOT_OK;
+    }
+    return OK;
+}
+
+int JsonHelper::jsonToBuffer(buffer *buffer, const json& json) {
+	const std::string tmp = nlohmann::to_string(json);
+	if (allocate(buffer, tmp.size()) == NOT_OK) {
+		return NOT_OK;
+	}
+	std::memcpy(buffer->data, tmp.c_str(), tmp.size());
+	return OK;
+}
+
+MissionModule::AutonomyStatus_State JsonHelper::stringToAutonomyState(const std::string_view &state) {
+	if (state == "IDLE") {
+		return MissionModule::AutonomyStatus_State::AutonomyStatus_State_IDLE;
+	} else if (state == "DRIVE") {
+		return MissionModule::AutonomyStatus_State::AutonomyStatus_State_DRIVE;
+	} else if (state == "IN_STOP") {
+		return MissionModule::AutonomyStatus_State::AutonomyStatus_State_IN_STOP;
+	} else if (state == "OBSTACLE") {
+		return MissionModule::AutonomyStatus_State::AutonomyStatus_State_OBSTACLE;
+	} else if (state == "ERROR") {
+		return MissionModule::AutonomyStatus_State::AutonomyStatus_State_ERROR;
+	}
+	return MissionModule::AutonomyStatus_State::AutonomyStatus_State_ERROR;
+}
+
+std::string JsonHelper::autonomyStateToString(const MissionModule::AutonomyStatus_State state) {
+    switch (state) {
+        case MissionModule::AutonomyStatus_State::AutonomyStatus_State_IDLE:
+            return "IDLE";
+        case MissionModule::AutonomyStatus_State::AutonomyStatus_State_DRIVE:
+            return "DRIVE";
+        case MissionModule::AutonomyStatus_State::AutonomyStatus_State_IN_STOP:
+            return "IN_STOP";
+        case MissionModule::AutonomyStatus_State::AutonomyStatus_State_OBSTACLE:
+            return "OBSTACLE";
+        default:
+            return "ERROR";
+    }
+}
+
+std::string JsonHelper::autonomyActionToString(const MissionModule::AutonomyCommand_Action action) {
+    switch (action) {
+        case MissionModule::AutonomyCommand_Action::AutonomyCommand_Action_STOP:
+            return "STOP";
+        case MissionModule::AutonomyCommand_Action::AutonomyCommand_Action_START:
+            return "DRIVE";
+        default:
+            return "NO_ACTION";
+    }
+}
+
+}