fsfw/src/fsfw/osal/linux/CommandExecutor.cpp

#include "CommandExecutor.h"

#include "fsfw/serviceinterface.h"
#include "fsfw/container/SimpleRingBuffer.h"
#include "fsfw/container/DynamicFIFO.h"

#include <unistd.h>

#include <cstring>

CommandExecutor::CommandExecutor(const size_t maxSize):
readVec(maxSize) {
    waiter.events = POLLIN;
}

ReturnValue_t CommandExecutor::load(std::string command, bool blocking, bool printOutput) {
    if(state == States::PENDING) {
        return COMMAND_PENDING;
    }

    currentCmd = command;
    this->blocking = blocking;
    this->printOutput = printOutput;
    if(state == States::IDLE) {
        state = States::COMMAND_LOADED;
    }
    return HasReturnvaluesIF::RETURN_OK;
}

ReturnValue_t CommandExecutor::execute() {
    if(state == States::IDLE) {
        return NO_COMMAND_LOADED_OR_PENDING;
    }
    else if(state == States::PENDING) {
        return COMMAND_PENDING;
    }
    currentCmdFile = popen(currentCmd.c_str(), "r");
    if(currentCmdFile == nullptr) {
        lastError = errno;
        return HasReturnvaluesIF::RETURN_FAILED;
    }
    if(blocking) {
        return executeBlocking();
    }
    else {
        currentFd = fileno(currentCmdFile);
        waiter.fd = currentFd;
    }
    return HasReturnvaluesIF::RETURN_OK;
}

ReturnValue_t CommandExecutor::close() {
    if(state == States::PENDING) {
        // Attempt to close process, irrespective of if it is running or not
        if(currentCmdFile != nullptr) {
            pclose(currentCmdFile);
        }
    }
    return HasReturnvaluesIF::RETURN_OK;
}

void CommandExecutor::printLastError(std::string funcName) const {
    if(lastError != 0) {
        sif::error << funcName << " pclose failed with code " <<
                lastError << ": " << strerror(lastError) << std::endl;
    }
}

void CommandExecutor::setRingBuffer(SimpleRingBuffer *ringBuffer,
        DynamicFIFO<uint16_t>* sizesFifo) {
    this->ringBuffer = ringBuffer;
    this->sizesFifo = sizesFifo;
}

ReturnValue_t CommandExecutor::check(bool& bytesRead) {
    if(blocking) {
        return HasReturnvaluesIF::RETURN_OK;
    }
    switch(state) {
    case(States::IDLE):
    case(States::COMMAND_LOADED): {
        return NO_COMMAND_LOADED_OR_PENDING;
    }
    case(States::PENDING): {
        break;
    }
    }

    int result = poll(&waiter, 1, 0);
    switch(result) {
    case(0): {
        return HasReturnvaluesIF::RETURN_OK;
        break;
    }
    case(1): {
        if (waiter.revents & POLLIN) {
            ssize_t readBytes = read(currentFd, readVec.data(), readVec.size());
            if(readBytes == 0) {
                // Should not happen
                sif::warning << "CommandExecutor::check: "
                        "No bytes read after poll event.." << std::endl;
                break;
            }
            else if(readBytes > 0) {
                bytesRead = true;
                if(printOutput) {
                    // It is assumed the command output is line terminated
                    sif::info << currentCmd << " | " << readVec.data();
                }
                if(ringBuffer != nullptr) {
                    ringBuffer->writeData(reinterpret_cast<const uint8_t*>(
                            readVec.data()), readBytes);
                }
                if(sizesFifo != nullptr) {
                    if(not sizesFifo->full()) {
                        sizesFifo->insert(readBytes);
                    }
                }
                return BYTES_READ;
            }
            else {
                // Should also not happen
                sif::warning << "CommandExecutor::check: Error " << errno << ": " <<
                        strerror(errno) << std::endl;
            }
        }
        else if(waiter.revents & POLLERR) {
            sif::warning << "CommandExecuter::check: Poll error" << std::endl;
            return COMMAND_ERROR;
        }
        else if(waiter.revents & POLLHUP) {
            int result = pclose(currentCmdFile);
            if(result != 0) {
                lastError = result;
                return HasReturnvaluesIF::RETURN_FAILED;
            }
            state = States::IDLE;
            currentCmdFile = nullptr;
            currentFd = 0;
            return EXECUTION_FINISHED;
        }
        break;
    }
    }
    return HasReturnvaluesIF::RETURN_OK;
}

void CommandExecutor::reset() {
    CommandExecutor::close();
    currentCmdFile = nullptr;
    currentFd = 0;
    state = States::IDLE;
}

int CommandExecutor::getLastError() const {
    return this->lastError;
}

CommandExecutor::States CommandExecutor::getCurrentState() const {
    return state;
}

ReturnValue_t CommandExecutor::executeBlocking() {
    while(fgets(readVec.data(), readVec.size(), currentCmdFile) != nullptr) {
        std::string output(readVec.data());
        if(printOutput) {
            sif::info << currentCmd << " | " << output;
        }
        if(ringBuffer != nullptr) {
            ringBuffer->writeData(reinterpret_cast<const uint8_t*>(output.data()), output.size());
        }
        if(sizesFifo != nullptr) {
            if(not sizesFifo->full()) {
                sizesFifo->insert(output.size());
            }
        }
    }
    int result = pclose(currentCmdFile);
    if(result != 0) {
        lastError = result;
        return HasReturnvaluesIF::RETURN_FAILED;
    }
    return HasReturnvaluesIF::RETURN_OK;
}