Merge pull request #35 from bringauto/BAF-967/ignore_empty_commands_and_statuses

Baf 967/ignore empty commands and statuses

Author: MarioIvancik

CMakeLists.txt

@@ -2,7 +2,7 @@ CMAKE_MINIMUM_REQUIRED(VERSION 3.25 FATAL_ERROR)
 PROJECT(ModuleGateway)
 INCLUDE(GNUInstallDirs)
 
-SET(BRINGAUTO_MODULE_GATEWAY_VERSION 1.1.13)
+SET(BRINGAUTO_MODULE_GATEWAY_VERSION 1.2.0)
 ADD_COMPILE_DEFINITIONS(MODULE_GATEWAY_VERSION="${BRINGAUTO_MODULE_GATEWAY_VERSION}")
 SET(CMAKE_INSTALL_RPATH "$ORIGIN/../${CMAKE_INSTALL_LIBDIR}")
 SET(CMAKE_CXX_STANDARD 20)

Dockerfile

@@ -14,7 +14,7 @@ RUN cmake .. -DCMAKE_BUILD_TYPE=Release -DBRINGAUTO_GET_PACKAGES_ONLY=ON
 
 FROM bringauto/cpp-build-environment:latest AS mission_module_builder
 
-ARG MISSION_MODULE_VERSION=v1.2.9
+ARG MISSION_MODULE_VERSION=v1.2.11
 
 # Install mission module dependencies
 WORKDIR /home/bringauto/modules/
@@ -40,7 +40,7 @@ RUN cmake -DCMAKE_BUILD_TYPE=Release -DBRINGAUTO_INSTALL=ON -DCMAKE_INSTALL_PREF
 
 FROM bringauto/cpp-build-environment:latest AS io_module_builder
 
-ARG IO_MODULE_VERSION=v1.3.0
+ARG IO_MODULE_VERSION=v1.3.1
 
 # Install io module dependencies
 WORKDIR /home/bringauto/modules

include/bringauto/modules/Buffer.hpp

@@ -53,6 +53,15 @@ struct Buffer final {
 		return raw_buffer_.data != nullptr && raw_buffer_.size_in_bytes > 0;
 	}
 
+	/**
+	 * @brief Determine if buffer is empty.
+	 *
+	 * @return true if size of buffer is 0, false otherwise
+	 */
+	[[nodiscard]] bool isEmpty() const {
+		return raw_buffer_.size_in_bytes == 0;
+	}
+
 private:
 
 	/**

source/bringauto/common_utils/ProtobufUtils.cpp

@@ -24,7 +24,9 @@ ProtobufUtils::createInternalServerCommandMessage(const InternalProtocol::Device
 												  const modules::Buffer &command) {
 	InternalProtocol::InternalServer message {};
 	auto deviceCommand = message.mutable_devicecommand();
-	deviceCommand->set_commanddata(command.getStructBuffer().data, command.getStructBuffer().size_in_bytes);
+	if (command.isAllocated()) {
+		deviceCommand->set_commanddata(command.getStructBuffer().data, command.getStructBuffer().size_in_bytes);
+	}
 	auto device_ = deviceCommand->mutable_device();
 	device_->CopyFrom(device);
 	return message;
@@ -35,7 +37,9 @@ ProtobufUtils::createInternalClientStatusMessage(const InternalProtocol::Device
 												 const modules::Buffer &status) {
 	InternalProtocol::InternalClient message {};
 	auto deviceStatus = message.mutable_devicestatus();
-	deviceStatus->set_statusdata(status.getStructBuffer().data, status.getStructBuffer().size_in_bytes);
+	if (status.isAllocated()) {
+		deviceStatus->set_statusdata(status.getStructBuffer().data, status.getStructBuffer().size_in_bytes);
+	}
 	auto device_ = deviceStatus->mutable_device();
 	device_->CopyFrom(device);
 	return message;
@@ -45,7 +49,9 @@ InternalProtocol::DeviceStatus ProtobufUtils::createDeviceStatus(const structure
 																 const modules::Buffer &status) {
 	InternalProtocol::DeviceStatus deviceStatus {};
 	deviceStatus.mutable_device()->CopyFrom(deviceId.convertToIPDevice());
-	deviceStatus.set_statusdata(status.getStructBuffer().data, status.getStructBuffer().size_in_bytes);
+	if (status.isAllocated()) {
+		deviceStatus.set_statusdata(status.getStructBuffer().data, status.getStructBuffer().size_in_bytes);
+	}
 	return deviceStatus;
 }
 

source/bringauto/external_client/ErrorAggregator.cpp

@@ -26,11 +26,6 @@ ErrorAggregator::add_status_to_error_aggregator(const modules::Buffer& status, c
 		return DEVICE_NOT_SUPPORTED;
 	}
 
-	if(!status.isAllocated()) {
-		settings::Logger::logWarning("Invalid status data for device: {}", device.convertToString());
-		return NOT_OK;
-	}
-
 	if(not devices_.contains(device)) {
 		devices_.insert({ device, {}});
 	}
@@ -54,12 +49,7 @@ int ErrorAggregator::get_last_status(modules::Buffer &status, const structures::
 		return DEVICE_NOT_REGISTERED;
 	}
 
-	auto &lastStatus = devices_[device].lastStatus;
-
-	if(!lastStatus.isAllocated()) {
-		return NO_MESSAGE_AVAILABLE;
-	}
-	status = lastStatus;
+	status = devices_[device].lastStatus;
 	return OK;
 }
 

source/bringauto/external_client/connection/ExternalConnection.cpp

@@ -67,7 +67,9 @@ void ExternalConnection::sendStatus(const InternalProtocol::DeviceStatus &status
 
 		const auto &statusData = status.statusdata();
 		auto statusBuffer = moduleLibraryHandler->constructBuffer(statusData.size());
-		common_utils::ProtobufUtils::copyStatusToBuffer(status, statusBuffer);
+		if (!statusBuffer.isEmpty()) {
+			common_utils::ProtobufUtils::copyStatusToBuffer(status, statusBuffer);
+		}
 		errorAggregator.add_status_to_error_aggregator(statusBuffer, deviceId);
 	}
 
@@ -378,7 +380,9 @@ void ExternalConnection::fillErrorAggregatorWithNotAckedStatuses() {
 		const auto &statusData = notAckedStatus->getStatus().devicestatus().statusdata();
 		auto statusBuffer = moduleLibrary_.moduleLibraryHandlers.at(device.module())->constructBuffer(
 			statusData.size());
-		common_utils::ProtobufUtils::copyStatusToBuffer(notAckedStatus->getStatus().devicestatus(), statusBuffer);
+		if (!statusBuffer.isEmpty()) {
+			common_utils::ProtobufUtils::copyStatusToBuffer(notAckedStatus->getStatus().devicestatus(), statusBuffer);
+		}
 
 		auto deviceId = structures::DeviceIdentification(device);
 		errorAggregators[device.module()].add_status_to_error_aggregator(statusBuffer, deviceId);
@@ -397,7 +401,9 @@ void ExternalConnection::fillErrorAggregator(const InternalProtocol::DeviceStatu
 		const auto &statusData = deviceStatus.statusdata();
 		auto statusBuffer = moduleLibrary_.moduleLibraryHandlers.at(moduleNum)->constructBuffer(
 			statusData.size());
-		common_utils::ProtobufUtils::copyStatusToBuffer(deviceStatus, statusBuffer);
+		if (!statusBuffer.isEmpty()) {
+			common_utils::ProtobufUtils::copyStatusToBuffer(deviceStatus, statusBuffer);
+		}
 
 		auto deviceId = structures::DeviceIdentification(deviceStatus.device());
 		auto &errorAggregator = errorAggregators.at(moduleNum);

source/bringauto/external_client/connection/messages/SentMessagesHandler.cpp

@@ -24,7 +24,7 @@ void SentMessagesHandler::addNotAckedStatus(const ExternalProtocol::Status &stat
 int SentMessagesHandler::acknowledgeStatus(const ExternalProtocol::StatusResponse &statusResponse) {
 	std::scoped_lock lock {ackMutex_};
 	auto responseCounter = getStatusResponseCounter(statusResponse);
-	for(auto i = 0; i < notAckedStatuses_.size(); ++i) {
+	for(auto i = 0u; i < notAckedStatuses_.size(); ++i) {
 		if(getStatusCounter(notAckedStatuses_[i]->getStatus()) == responseCounter) {
 			notAckedStatuses_[i]->cancelTimer();
 			notAckedStatuses_.erase(notAckedStatuses_.begin() + i);

source/bringauto/modules/ModuleHandler.cpp

@@ -176,11 +176,13 @@ void ModuleHandler::handleStatus(const ip::DeviceStatus &status) {
 
 	const auto &statusData = status.statusdata();
 	auto statusBuffer = moduleHandler->constructBuffer(statusData.size());
-	common_utils::ProtobufUtils::copyStatusToBuffer(status, statusBuffer);
+	if (!statusBuffer.isEmpty()) {
+		common_utils::ProtobufUtils::copyStatusToBuffer(status, statusBuffer);
+	}
 
 	const auto deviceId = structures::DeviceIdentification(device);
 
-	if(!statusBuffer.isAllocated() || moduleHandler->statusDataValid(statusBuffer, deviceId.getDeviceType()) == NOT_OK) {
+	if(moduleHandler->statusDataValid(statusBuffer, deviceId.getDeviceType()) == NOT_OK) {
 		settings::Logger::logWarning("Invalid status data on device id: {}", deviceId.convertToString());
 		return;
 	}

source/bringauto/modules/ModuleManagerLibraryHandler.cpp

@@ -75,22 +75,40 @@ int ModuleManagerLibraryHandler::isDeviceTypeSupported(unsigned int device_type)
 int ModuleManagerLibraryHandler::sendStatusCondition(const Buffer current_status,
 													 const Buffer new_status,
 													 unsigned int device_type) {
-	return sendStatusCondition_(current_status.getStructBuffer(), new_status.getStructBuffer(), device_type);
+	struct ::buffer current_status_raw_buffer {};
+	struct ::buffer new_status_raw_buffer {};
+
+	if (current_status.isAllocated()) {
+		current_status_raw_buffer = current_status.getStructBuffer();
+	}
+	if (new_status.isAllocated()) {
+		new_status_raw_buffer = new_status.getStructBuffer();
+	}
+
+	return sendStatusCondition_(current_status_raw_buffer, new_status_raw_buffer, device_type);
 }
 
 int ModuleManagerLibraryHandler::generateCommand(Buffer &generated_command,
 												 const Buffer new_status,
 												 const Buffer current_status,
 												 const Buffer current_command, unsigned int device_type) {
 	struct ::buffer raw_buffer {};
+	struct ::buffer new_status_raw_buffer {};
 	struct ::buffer current_status_raw_buffer {};
+	struct ::buffer current_command_raw_buffer {};
 
+	if (new_status.isAllocated()) {
+		new_status_raw_buffer = new_status.getStructBuffer();
+	}
 	if (current_status.isAllocated()) {
 		current_status_raw_buffer = current_status.getStructBuffer();
 	}
+	if (current_command.isAllocated()) {
+		current_command_raw_buffer = current_command.getStructBuffer();
+	}
 
-	int ret = generateCommand_(&raw_buffer, new_status.getStructBuffer(),
-		current_status_raw_buffer, current_command.getStructBuffer(), device_type);
+	int ret = generateCommand_(&raw_buffer, new_status_raw_buffer,
+		current_status_raw_buffer, current_command_raw_buffer, device_type);
 	if (ret == OK) {
 		generated_command = constructBufferByTakeOwnership(raw_buffer);
 	} else {
@@ -104,12 +122,16 @@ int ModuleManagerLibraryHandler::aggregateStatus(Buffer &aggregated_status,
 												 const Buffer new_status, unsigned int device_type) {
 	struct ::buffer raw_buffer {};
 	struct ::buffer current_status_raw_buffer {};
+	struct ::buffer new_status_raw_buffer {};
 
 	if (current_status.isAllocated()) {
 		current_status_raw_buffer = current_status.getStructBuffer();
 	}
+	if (new_status.isAllocated()) {
+		new_status_raw_buffer = new_status.getStructBuffer();
+	}
 
-	int ret = aggregateStatus_(&raw_buffer, current_status_raw_buffer, new_status.getStructBuffer(), device_type);
+	int ret = aggregateStatus_(&raw_buffer, current_status_raw_buffer, new_status_raw_buffer, device_type);
 	if (ret == OK) {
 		aggregated_status = constructBufferByTakeOwnership(raw_buffer);
 	} else {
@@ -124,12 +146,16 @@ int ModuleManagerLibraryHandler::aggregateError(Buffer &error_message,
 
 	struct ::buffer raw_buffer {};
 	struct ::buffer current_error_raw_buffer {};
+	struct ::buffer status_raw_buffer {};
 
 	if (current_error_message.isAllocated()) {
 		current_error_raw_buffer = current_error_message.getStructBuffer();
 	}
+	if (status.isAllocated()) {
+		status_raw_buffer = status.getStructBuffer();
+	}
 
-	int ret = aggregateError_(&raw_buffer, current_error_raw_buffer, status.getStructBuffer(), device_type);
+	int ret = aggregateError_(&raw_buffer, current_error_raw_buffer, status_raw_buffer, device_type);
 	if (ret == OK) {
 		error_message = constructBufferByTakeOwnership(raw_buffer);
 	} else {
@@ -150,11 +176,19 @@ int ModuleManagerLibraryHandler::generateFirstCommand(Buffer &default_command, u
 }
 
 int ModuleManagerLibraryHandler::statusDataValid(const Buffer status, unsigned int device_type) {
-	return statusDataValid_(status.getStructBuffer(), device_type);
+	struct ::buffer raw_buffer {};
+	if (status.isAllocated()) {
+		raw_buffer = status.getStructBuffer();
+	}
+	return statusDataValid_(raw_buffer, device_type);
 }
 
 int ModuleManagerLibraryHandler::commandDataValid(const Buffer command, unsigned int device_type) {
-	return commandDataValid_(command.getStructBuffer(), device_type);
+	struct ::buffer raw_buffer {};
+	if (command.isAllocated()) {
+		raw_buffer = command.getStructBuffer();
+	}
+	return commandDataValid_(raw_buffer, device_type);
 }
 
 int ModuleManagerLibraryHandler::allocate(struct buffer *buffer_pointer, size_t size_in_bytes){