EventManager.cpp

Go to the documentation of this file.

/*
 * TestCommand1Impl.cpp
 *
 *  Created on: Mar 28, 2014
 *      Author: tcanham
 */

#include <Fw/Types/Assert.hpp>
#include <Os/File.hpp>
#include <Svc/EventManager/EventManager.hpp>

namespace Svc {
static_assert(std::numeric_limits<FwSizeType>::max() >= TELEM_ID_FILTER_SIZE,
              "TELEM_ID_FILTER_SIZE must fit within range of FwSizeType");
typedef EventManager_Enabled Enabled;
typedef EventManager_FilterSeverity FilterSeverity;

EventManager::EventManager(const char* name) : EventManagerComponentBase(name) {
    // set filter defaults
    this->m_filterState[FilterSeverity::WARNING_HI].enabled =
        FILTER_WARNING_HI_DEFAULT ? Enabled::ENABLED : Enabled::DISABLED;
    this->m_filterState[FilterSeverity::WARNING_LO].enabled =
        FILTER_WARNING_LO_DEFAULT ? Enabled::ENABLED : Enabled::DISABLED;
    this->m_filterState[FilterSeverity::COMMAND].enabled =
        FILTER_COMMAND_DEFAULT ? Enabled::ENABLED : Enabled::DISABLED;
    this->m_filterState[FilterSeverity::ACTIVITY_HI].enabled =
        FILTER_ACTIVITY_HI_DEFAULT ? Enabled::ENABLED : Enabled::DISABLED;
    this->m_filterState[FilterSeverity::ACTIVITY_LO].enabled =
        FILTER_ACTIVITY_LO_DEFAULT ? Enabled::ENABLED : Enabled::DISABLED;
    this->m_filterState[FilterSeverity::DIAGNOSTIC].enabled =
        FILTER_DIAGNOSTIC_DEFAULT ? Enabled::ENABLED : Enabled::DISABLED;
}

EventManager::~EventManager() {}

void EventManager::LogRecv_handler(FwIndexType portNum,
                                   FwEventIdType id,
                                   Fw::Time& timeTag,
                                   const Fw::LogSeverity& severity,
                                   Fw::LogBuffer& args) {
    switch (severity.e) {
        case Fw::LogSeverity::FATAL:  // always pass FATAL
            break;
        case Fw::LogSeverity::WARNING_HI:
            if (this->m_filterState[FilterSeverity::WARNING_HI].enabled == Enabled::DISABLED) {
                return;
            }
            break;
        case Fw::LogSeverity::WARNING_LO:
            if (this->m_filterState[FilterSeverity::WARNING_LO].enabled == Enabled::DISABLED) {
                return;
            }
            break;
        case Fw::LogSeverity::COMMAND:
            if (this->m_filterState[FilterSeverity::COMMAND].enabled == Enabled::DISABLED) {
                return;
            }
            break;
        case Fw::LogSeverity::ACTIVITY_HI:
            if (this->m_filterState[FilterSeverity::ACTIVITY_HI].enabled == Enabled::DISABLED) {
                return;
            }
            break;
        case Fw::LogSeverity::ACTIVITY_LO:
            if (this->m_filterState[FilterSeverity::ACTIVITY_LO].enabled == Enabled::DISABLED) {
                return;
            }
            break;
        case Fw::LogSeverity::DIAGNOSTIC:
            if (this->m_filterState[FilterSeverity::DIAGNOSTIC].enabled == Enabled::DISABLED) {
                return;
            }
            break;
        default:
            FW_ASSERT(false, static_cast<FwAssertArgType>(severity.e));
            return;
    }

    // check ID filters
    Fw::Success findStatus = m_filteredIDs.find(id);
    if ((findStatus == Fw::Success::SUCCESS) && (severity != Fw::LogSeverity::FATAL)) {
        return;
    }

    // send event to the logger thread
    this->loqQueue_internalInterfaceInvoke(id, timeTag, severity, args);

    // if connected, announce the FATAL
    if (Fw::LogSeverity::FATAL == severity.e) {
        if (this->isConnected_FatalAnnounce_OutputPort(0)) {
            this->FatalAnnounce_out(0, id);
        }
    }
}

void EventManager::loqQueue_internalInterfaceHandler(FwEventIdType id,
                                                     const Fw::Time& timeTag,
                                                     const Fw::LogSeverity& severity,
                                                     const Fw::LogBuffer& args) {
    // Serialize event
    this->m_logPacket.setId(id);
    this->m_logPacket.setTimeTag(timeTag);
    this->m_logPacket.setLogBuffer(args);
    this->m_comBuffer.resetSer();
    Fw::SerializeStatus stat = this->m_logPacket.serializeTo(this->m_comBuffer);
    FW_ASSERT(Fw::FW_SERIALIZE_OK == stat, static_cast<FwAssertArgType>(stat));

    if (this->isConnected_PktSend_OutputPort(0)) {
        this->PktSend_out(0, this->m_comBuffer, 0);
    }
}

void EventManager::SET_EVENT_FILTER_cmdHandler(FwOpcodeType opCode,
                                               U32 cmdSeq,
                                               const FilterSeverity& filterLevel,
                                               const Enabled& filterEnable) {
    this->m_filterState[filterLevel.e].enabled = filterEnable;
    this->cmdResponse_out(opCode, cmdSeq, Fw::CmdResponse::OK);
}

void EventManager::SET_ID_FILTER_cmdHandler(FwOpcodeType opCode,  
                                            U32 cmdSeq,           
                                            FwEventIdType ID,
                                            const Enabled& idEnabled  
) {
    if (Enabled::ENABLED == idEnabled.e) {  // add ID
        if (m_filteredIDs.insert(ID) == Fw::Success::SUCCESS) {
            this->cmdResponse_out(opCode, cmdSeq, Fw::CmdResponse::OK);
            this->log_ACTIVITY_HI_ID_FILTER_ENABLED(ID);
        } else {
            // if an empty slot was not found, send an error event
            this->log_WARNING_LO_ID_FILTER_LIST_FULL(ID);
            this->cmdResponse_out(opCode, cmdSeq, Fw::CmdResponse::EXECUTION_ERROR);
        }
    } else {  // remove ID
        if (m_filteredIDs.remove(ID) == Fw::Success::SUCCESS) {
            this->cmdResponse_out(opCode, cmdSeq, Fw::CmdResponse::OK);
            this->log_ACTIVITY_HI_ID_FILTER_REMOVED(ID);
        } else {
            // Entry wasn't found
            this->log_WARNING_LO_ID_FILTER_NOT_FOUND(ID);
            this->cmdResponse_out(opCode, cmdSeq, Fw::CmdResponse::EXECUTION_ERROR);
        }
    }
}

void EventManager::DUMP_FILTER_STATE_cmdHandler(FwOpcodeType opCode,  
                                                U32 cmdSeq            
) {
    // first, iterate through severity filters
    for (FwEnumStoreType filter = 0; filter < FilterSeverity::NUM_CONSTANTS; filter++) {
        FilterSeverity filterState(static_cast<FilterSeverity::t>(filter));
        FW_ASSERT(this->m_filterState[filter].enabled.isValid(), static_cast<FwAssertArgType>(filter));
        this->log_ACTIVITY_LO_SEVERITY_FILTER_STATE(filterState,
                                                    Enabled::ENABLED == this->m_filterState[filter].enabled.e);
    }

    // iterate through ID filter
    for (FwEventIdType ID : m_filteredIDs) {
        this->log_ACTIVITY_HI_ID_FILTER_ENABLED(ID);
    }

    this->cmdResponse_out(opCode, cmdSeq, Fw::CmdResponse::OK);
}

void EventManager::run_handler(FwIndexType portNum, U32 context) {
    this->tlmWrite_EventsDropped(this->getNumMsgsDropped());
}

void EventManager::pingIn_handler(const FwIndexType portNum, U32 key) {
    // return key
    this->pingOut_out(0, key);
}

}  // namespace Svc