restructure repository

src/core/action/ActionHelper.cpp

@@ -0,0 +1,167 @@
+#include "ActionHelper.h"
+#include "HasActionsIF.h"
+
+#include "../ipc/MessageQueueSenderIF.h"
+#include "../objectmanager/ObjectManager.h"
+#include "../serviceinterface/ServiceInterface.h"
+
+ActionHelper::ActionHelper(HasActionsIF* setOwner,
+        MessageQueueIF* useThisQueue) :
+        owner(setOwner), queueToUse(useThisQueue) {
+}
+
+ActionHelper::~ActionHelper() {
+}
+
+ReturnValue_t ActionHelper::handleActionMessage(CommandMessage* command) {
+    if (command->getCommand() == ActionMessage::EXECUTE_ACTION) {
+        ActionId_t currentAction = ActionMessage::getActionId(command);
+        prepareExecution(command->getSender(), currentAction,
+                ActionMessage::getStoreId(command));
+        return HasReturnvaluesIF::RETURN_OK;
+    } else {
+        return CommandMessage::UNKNOWN_COMMAND;
+    }
+}
+
+ReturnValue_t ActionHelper::initialize(MessageQueueIF* queueToUse_) {
+    ipcStore = ObjectManager::instance()->get<StorageManagerIF>(objects::IPC_STORE);
+    if (ipcStore == nullptr) {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    if(queueToUse_ != nullptr) {
+        setQueueToUse(queueToUse_);
+    }
+
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+void ActionHelper::step(uint8_t step, MessageQueueId_t reportTo,
+        ActionId_t commandId, ReturnValue_t result) {
+    CommandMessage reply;
+    ActionMessage::setStepReply(&reply, commandId, step + STEP_OFFSET, result);
+    queueToUse->sendMessage(reportTo, &reply);
+}
+
+void ActionHelper::finish(bool success, MessageQueueId_t reportTo, ActionId_t commandId,
+        ReturnValue_t result) {
+    CommandMessage reply;
+    ActionMessage::setCompletionReply(&reply, commandId, success, result);
+    queueToUse->sendMessage(reportTo, &reply);
+}
+
+void ActionHelper::setQueueToUse(MessageQueueIF* queue) {
+    queueToUse = queue;
+}
+
+void ActionHelper::prepareExecution(MessageQueueId_t commandedBy,
+        ActionId_t actionId, store_address_t dataAddress) {
+    const uint8_t* dataPtr = NULL;
+    size_t size = 0;
+    ReturnValue_t result = ipcStore->getData(dataAddress, &dataPtr, &size);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        CommandMessage reply;
+        ActionMessage::setStepReply(&reply, actionId, 0, result);
+        queueToUse->sendMessage(commandedBy, &reply);
+        return;
+    }
+    result = owner->executeAction(actionId, commandedBy, dataPtr, size);
+    ipcStore->deleteData(dataAddress);
+    if(result == HasActionsIF::EXECUTION_FINISHED) {
+        CommandMessage reply;
+        ActionMessage::setCompletionReply(&reply, actionId, true, result);
+        queueToUse->sendMessage(commandedBy, &reply);
+    }
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        CommandMessage reply;
+        ActionMessage::setStepReply(&reply, actionId, 0, result);
+        queueToUse->sendMessage(commandedBy, &reply);
+        return;
+    }
+}
+
+ReturnValue_t ActionHelper::reportData(MessageQueueId_t reportTo,
+        ActionId_t replyId, SerializeIF* data, bool hideSender) {
+    CommandMessage reply;
+    store_address_t storeAddress;
+    uint8_t *dataPtr;
+    size_t maxSize = data->getSerializedSize();
+    if (maxSize == 0) {
+        /* No error, there's simply nothing to report. */
+        return HasReturnvaluesIF::RETURN_OK;
+    }
+    size_t size = 0;
+    ReturnValue_t result = ipcStore->getFreeElement(&storeAddress, maxSize,
+            &dataPtr);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::warning << "ActionHelper::reportData: Getting free element from IPC store failed!" <<
+                std::endl;
+#else
+        sif::printWarning("ActionHelper::reportData: Getting free element from IPC "
+                "store failed!\n");
+#endif
+        return result;
+    }
+    result = data->serialize(&dataPtr, &size, maxSize,
+            SerializeIF::Endianness::BIG);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        ipcStore->deleteData(storeAddress);
+        return result;
+    }
+
+    /* We don't need to report the objectId, as we receive REQUESTED data before the completion
+    success message. True aperiodic replies need to be reported with another dedicated message. */
+    ActionMessage::setDataReply(&reply, replyId, storeAddress);
+
+    /* If the sender needs to be hidden, for example to handle packet
+    as unrequested reply, this will be done here. */
+    if (hideSender) {
+        result = MessageQueueSenderIF::sendMessage(reportTo, &reply);
+    }
+    else {
+        result = queueToUse->sendMessage(reportTo, &reply);
+    }
+
+    if (result != HasReturnvaluesIF::RETURN_OK){
+        ipcStore->deleteData(storeAddress);
+    }
+    return result;
+}
+
+void ActionHelper::resetHelper() {
+}
+
+ReturnValue_t ActionHelper::reportData(MessageQueueId_t reportTo,
+        ActionId_t replyId, const uint8_t *data, size_t dataSize,
+        bool hideSender) {
+    CommandMessage reply;
+    store_address_t storeAddress;
+    ReturnValue_t result = ipcStore->addData(&storeAddress, data, dataSize);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::warning << "ActionHelper::reportData: Adding data to IPC store failed!" << std::endl;
+#else
+        sif::printWarning("ActionHelper::reportData: Adding data to IPC store failed!\n");
+#endif
+        return result;
+    }
+
+    /* We don't need to report the objectId, as we receive REQUESTED data before the completion
+    success message. True aperiodic replies need to be reported with another dedicated message. */
+    ActionMessage::setDataReply(&reply, replyId, storeAddress);
+
+    /* If the sender needs to be hidden, for example to handle packet
+    as unrequested reply, this will be done here. */
+    if (hideSender) {
+        result = MessageQueueSenderIF::sendMessage(reportTo, &reply);
+    }
+    else {
+        result = queueToUse->sendMessage(reportTo, &reply);
+    }
+
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        ipcStore->deleteData(storeAddress);
+    }
+    return result;
+}

src/core/action/ActionMessage.cpp

@@ -0,0 +1,82 @@
+#include "ActionMessage.h"
+#include "HasActionsIF.h"
+
+#include "../objectmanager/ObjectManager.h"
+#include "../storagemanager/StorageManagerIF.h"
+
+ActionMessage::ActionMessage() {
+}
+
+ActionMessage::~ActionMessage() {
+}
+
+void ActionMessage::setCommand(CommandMessage* message, ActionId_t fid,
+        store_address_t parameters) {
+    message->setCommand(EXECUTE_ACTION);
+    message->setParameter(fid);
+    message->setParameter2(parameters.raw);
+}
+
+ActionId_t ActionMessage::getActionId(const CommandMessage* message) {
+    return ActionId_t(message->getParameter());
+}
+
+store_address_t ActionMessage::getStoreId(const CommandMessage* message) {
+    store_address_t temp;
+    temp.raw = message->getParameter2();
+    return temp;
+}
+
+void ActionMessage::setStepReply(CommandMessage* message, ActionId_t fid, uint8_t step,
+        ReturnValue_t result) {
+    if (result == HasReturnvaluesIF::RETURN_OK) {
+        message->setCommand(STEP_SUCCESS);
+    } else {
+        message->setCommand(STEP_FAILED);
+    }
+    message->setParameter(fid);
+    message->setParameter2((step << 16) + result);
+}
+
+uint8_t ActionMessage::getStep(const CommandMessage* message) {
+    return uint8_t((message->getParameter2() >> 16) & 0xFF);
+}
+
+ReturnValue_t ActionMessage::getReturnCode(const CommandMessage* message) {
+    return message->getParameter2() & 0xFFFF;
+}
+
+void ActionMessage::setDataReply(CommandMessage* message, ActionId_t actionId,
+        store_address_t data) {
+    message->setCommand(DATA_REPLY);
+    message->setParameter(actionId);
+    message->setParameter2(data.raw);
+}
+
+void ActionMessage::setCompletionReply(CommandMessage* message,
+        ActionId_t fid, bool success, ReturnValue_t result) {
+    if (success) {
+        message->setCommand(COMPLETION_SUCCESS);
+    }
+    else {
+        message->setCommand(COMPLETION_FAILED);
+    }
+    message->setParameter(fid);
+    message->setParameter2(result);
+}
+
+void ActionMessage::clear(CommandMessage* message) {
+    switch(message->getCommand()) {
+    case EXECUTE_ACTION:
+    case DATA_REPLY: {
+        StorageManagerIF *ipcStore = ObjectManager::instance()->get<StorageManagerIF>(
+                objects::IPC_STORE);
+        if (ipcStore != NULL) {
+            ipcStore->deleteData(getStoreId(message));
+        }
+        break;
+    }
+    default:
+        break;
+    }
+}

src/core/action/CMakeLists.txt

@@ -0,0 +1,7 @@
+target_sources(${LIB_FSFW_NAME} 
+    PRIVATE 
+        ActionHelper.cpp
+        ActionMessage.cpp
+        CommandActionHelper.cpp
+        SimpleActionHelper.cpp
+)

src/core/action/CommandActionHelper.cpp

@@ -0,0 +1,128 @@
+#include "ActionMessage.h"
+#include "CommandActionHelper.h"
+#include "CommandsActionsIF.h"
+#include "HasActionsIF.h"
+
+#include "../objectmanager/ObjectManager.h"
+
+CommandActionHelper::CommandActionHelper(CommandsActionsIF *setOwner) :
+        owner(setOwner), queueToUse(NULL), ipcStore(
+        NULL), commandCount(0), lastTarget(0) {
+}
+
+CommandActionHelper::~CommandActionHelper() {
+}
+
+ReturnValue_t CommandActionHelper::commandAction(object_id_t commandTo,
+        ActionId_t actionId, SerializeIF *data) {
+    HasActionsIF *receiver = ObjectManager::instance()->get<HasActionsIF>(commandTo);
+    if (receiver == NULL) {
+        return CommandsActionsIF::OBJECT_HAS_NO_FUNCTIONS;
+    }
+    store_address_t storeId;
+    uint8_t *storePointer;
+    size_t maxSize = data->getSerializedSize();
+    ReturnValue_t result = ipcStore->getFreeElement(&storeId, maxSize,
+            &storePointer);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
+    size_t size = 0;
+    result = data->serialize(&storePointer, &size, maxSize,
+            SerializeIF::Endianness::BIG);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
+    return sendCommand(receiver->getCommandQueue(), actionId, storeId);
+}
+
+ReturnValue_t CommandActionHelper::commandAction(object_id_t commandTo,
+        ActionId_t actionId, const uint8_t *data, uint32_t size) {
+//    if (commandCount != 0) {
+//        return CommandsFunctionsIF::ALREADY_COMMANDING;
+//    }
+    HasActionsIF *receiver = ObjectManager::instance()->get<HasActionsIF>(commandTo);
+    if (receiver == NULL) {
+        return CommandsActionsIF::OBJECT_HAS_NO_FUNCTIONS;
+    }
+    store_address_t storeId;
+    ReturnValue_t result = ipcStore->addData(&storeId, data, size);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
+    return sendCommand(receiver->getCommandQueue(), actionId, storeId);
+}
+
+ReturnValue_t CommandActionHelper::sendCommand(MessageQueueId_t queueId,
+        ActionId_t actionId, store_address_t storeId) {
+    CommandMessage command;
+    ActionMessage::setCommand(&command, actionId, storeId);
+    ReturnValue_t result = queueToUse->sendMessage(queueId, &command);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        ipcStore->deleteData(storeId);
+    }
+    lastTarget = queueId;
+    commandCount++;
+    return result;
+}
+
+ReturnValue_t CommandActionHelper::initialize() {
+    ipcStore = ObjectManager::instance()->get<StorageManagerIF>(objects::IPC_STORE);
+    if (ipcStore == NULL) {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+
+    queueToUse = owner->getCommandQueuePtr();
+    if (queueToUse == NULL) {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t CommandActionHelper::handleReply(CommandMessage *reply) {
+    if (reply->getSender() != lastTarget) {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    switch (reply->getCommand()) {
+    case ActionMessage::COMPLETION_SUCCESS:
+        commandCount--;
+        owner->completionSuccessfulReceived(ActionMessage::getActionId(reply));
+        return HasReturnvaluesIF::RETURN_OK;
+    case ActionMessage::COMPLETION_FAILED:
+        commandCount--;
+        owner->completionFailedReceived(ActionMessage::getActionId(reply),
+                ActionMessage::getReturnCode(reply));
+        return HasReturnvaluesIF::RETURN_OK;
+    case ActionMessage::STEP_SUCCESS:
+        owner->stepSuccessfulReceived(ActionMessage::getActionId(reply),
+                ActionMessage::getStep(reply));
+        return HasReturnvaluesIF::RETURN_OK;
+    case ActionMessage::STEP_FAILED:
+        commandCount--;
+        owner->stepFailedReceived(ActionMessage::getActionId(reply),
+                ActionMessage::getStep(reply),
+                ActionMessage::getReturnCode(reply));
+        return HasReturnvaluesIF::RETURN_OK;
+    case ActionMessage::DATA_REPLY:
+        extractDataForOwner(ActionMessage::getActionId(reply),
+                ActionMessage::getStoreId(reply));
+        return HasReturnvaluesIF::RETURN_OK;
+    default:
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+}
+
+uint8_t CommandActionHelper::getCommandCount() const {
+    return commandCount;
+}
+
+void CommandActionHelper::extractDataForOwner(ActionId_t actionId, store_address_t storeId) {
+    const uint8_t * data = NULL;
+    size_t size = 0;
+    ReturnValue_t result = ipcStore->getData(storeId, &data, &size);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        return;
+    }
+    owner->dataReceived(actionId, data, size);
+    ipcStore->deleteData(storeId);
+}

src/core/action/SimpleActionHelper.cpp

@@ -0,0 +1,75 @@
+#include "HasActionsIF.h"
+#include "SimpleActionHelper.h"
+
+SimpleActionHelper::SimpleActionHelper(HasActionsIF* setOwner,
+        MessageQueueIF* useThisQueue) :
+        ActionHelper(setOwner, useThisQueue), isExecuting(false) {
+}
+
+SimpleActionHelper::~SimpleActionHelper() {
+}
+
+void SimpleActionHelper::step(ReturnValue_t result) {
+    // STEP_OFFESET is subtracted to compensate for adding offset in base
+    // method, which is not necessary here.
+    ActionHelper::step(stepCount - STEP_OFFSET, lastCommander, lastAction,
+            result);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        resetHelper();
+    }
+}
+
+void SimpleActionHelper::finish(ReturnValue_t result) {
+    ActionHelper::finish(lastCommander, lastAction, result);
+    resetHelper();
+}
+
+ReturnValue_t SimpleActionHelper::reportData(SerializeIF* data) {
+    return ActionHelper::reportData(lastCommander, lastAction, data);
+}
+
+void SimpleActionHelper::resetHelper() {
+    stepCount = 0;
+    isExecuting = false;
+    lastAction = 0;
+    lastCommander = 0;
+}
+
+void SimpleActionHelper::prepareExecution(MessageQueueId_t commandedBy,
+        ActionId_t actionId, store_address_t dataAddress) {
+    CommandMessage reply;
+    if (isExecuting) {
+        ipcStore->deleteData(dataAddress);
+        ActionMessage::setStepReply(&reply, actionId, 0,
+                HasActionsIF::IS_BUSY);
+        queueToUse->sendMessage(commandedBy, &reply);
+    }
+    const uint8_t* dataPtr = NULL;
+    size_t size = 0;
+    ReturnValue_t result = ipcStore->getData(dataAddress, &dataPtr, &size);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        ActionMessage::setStepReply(&reply, actionId, 0, result);
+        queueToUse->sendMessage(commandedBy, &reply);
+        return;
+    }
+    lastCommander = commandedBy;
+    lastAction = actionId;
+    result = owner->executeAction(actionId, commandedBy, dataPtr, size);
+    ipcStore->deleteData(dataAddress);
+    switch (result) {
+    case HasReturnvaluesIF::RETURN_OK:
+        isExecuting = true;
+        stepCount++;
+        break;
+    case HasActionsIF::EXECUTION_FINISHED:
+        ActionMessage::setCompletionReply(&reply, actionId,
+                true, HasReturnvaluesIF::RETURN_OK);
+        queueToUse->sendMessage(commandedBy, &reply);
+        break;
+    default:
+        ActionMessage::setStepReply(&reply, actionId, 0, result);
+        queueToUse->sendMessage(commandedBy, &reply);
+        break;
+    }
+
+}