CfdpManager.hpp

Go to the documentation of this file.

// ======================================================================
// \title  CfdpManager.hpp
// \author Brian Campuzano
// \brief  hpp file for CfdpManager component implementation class
// ======================================================================

#ifndef CCSDS_CFDPMANAGER_HPP
#define CCSDS_CFDPMANAGER_HPP

#include <Fw/Types/MemAllocator.hpp>
#include <Fw/Types/String.hpp>
#include <Os/Queue.hpp>
#include <Svc/Ccsds/CfdpManager/CfdpManagerComponentAc.hpp>
#include <Svc/Ccsds/CfdpManager/Types/StatusEnumAc.hpp>

namespace Svc {
namespace Ccsds {
namespace Cfdp {

// Forward declarations
class Engine;
class Channel;
class Transaction;

class CfdpManager final : public CfdpManagerComponentBase {
    friend class CfdpManagerTester;
    // Give access to protected functions for EVRs and Telemetry
    friend class Engine;
    friend class Channel;
    friend class Transaction;

  public:
    // ----------------------------------------------------------------------
    // Component construction and destruction
    // ----------------------------------------------------------------------

    CfdpManager(const char* const compName  
    );

    ~CfdpManager();

    void configure(Fw::MemAllocator& allocator, FwSizeType fileQueueDepth, FwEnumStoreType memId = 0);

    void cleanup();

    void deinit() override;

  public:
    // ----------------------------------------------------------------------
    // Constants
    // ----------------------------------------------------------------------

    static constexpr FwSizeType PACKET_DESCRIPTOR_SIZE = sizeof(FwPacketDescriptorType);

    // ----------------------------------------------------------------------
    // Port calls that are invoked by the CFDP engine
    // These functions are analogous to the functions in cf_cfdp_sbintf.*
    // However these functions are not direct ports due to the architectural
    // differences between F' and cFE
    // ----------------------------------------------------------------------

    Status::T getPduBuffer(Fw::Buffer& buffer, Channel& channel, FwSizeType size);

    void returnPduBuffer(Channel& channel, Fw::Buffer& pduBuffer);

    void sendPduBuffer(Channel& channel, Fw::Buffer& pduBuffer);

    void sendFileComplete(Svc::SendFileStatus::T status);

    // ----------------------------------------------------------------
    // Telemetry helper methods (public for Engine/Transaction access)
    // ----------------------------------------------------------------

    void incrementRecvErrors(U8 chanId) {
        FW_ASSERT(chanId < Cfdp::NumChannels, chanId);
        m_channelTelemetry[chanId].set_recvErrors(m_channelTelemetry[chanId].get_recvErrors() + 1);
    }

    void incrementRecvDropped(U8 chanId) {
        FW_ASSERT(chanId < Cfdp::NumChannels, chanId);
        m_channelTelemetry[chanId].set_recvDropped(m_channelTelemetry[chanId].get_recvDropped() + 1);
    }

    void incrementRecvSpurious(U8 chanId) {
        FW_ASSERT(chanId < Cfdp::NumChannels, chanId);
        m_channelTelemetry[chanId].set_recvSpurious(m_channelTelemetry[chanId].get_recvSpurious() + 1);
    }

    void addRecvFileDataBytes(U8 chanId, U32 bytes) {
        FW_ASSERT(chanId < Cfdp::NumChannels, chanId);
        m_channelTelemetry[chanId].set_recvFileDataBytes(m_channelTelemetry[chanId].get_recvFileDataBytes() + bytes);
    }

    void addRecvNakSegmentRequests(U8 chanId, U32 count) {
        FW_ASSERT(chanId < Cfdp::NumChannels, chanId);
        m_channelTelemetry[chanId].set_recvNakSegmentRequests(m_channelTelemetry[chanId].get_recvNakSegmentRequests() +
                                                              count);
    }

    void incrementRecvPdu(U8 chanId) {
        FW_ASSERT(chanId < Cfdp::NumChannels, chanId);
        m_channelTelemetry[chanId].set_recvPdu(m_channelTelemetry[chanId].get_recvPdu() + 1);
    }

    void incrementRecvEofCanceled(U8 chanId) {
        FW_ASSERT(chanId < Cfdp::NumChannels, chanId);
        m_channelTelemetry[chanId].set_recvEofCanceled(m_channelTelemetry[chanId].get_recvEofCanceled() + 1);
    }

    void addSentNakSegmentRequests(U8 chanId, U32 count) {
        FW_ASSERT(chanId < Cfdp::NumChannels, chanId);
        m_channelTelemetry[chanId].set_sentNakSegmentRequests(m_channelTelemetry[chanId].get_sentNakSegmentRequests() +
                                                              count);
    }

    void addSentFileDataBytes(U8 chanId, U32 bytes) {
        FW_ASSERT(chanId < Cfdp::NumChannels, chanId);
        m_channelTelemetry[chanId].set_sentFileDataBytes(m_channelTelemetry[chanId].get_sentFileDataBytes() + bytes);
    }

    void incrementSentPdu(U8 chanId) {
        FW_ASSERT(chanId < Cfdp::NumChannels, chanId);
        m_channelTelemetry[chanId].set_sentPdu(m_channelTelemetry[chanId].get_sentPdu() + 1);
    }

    void incrementSentEofCanceled(U8 chanId) {
        FW_ASSERT(chanId < Cfdp::NumChannels, chanId);
        m_channelTelemetry[chanId].set_sentEofCanceled(m_channelTelemetry[chanId].get_sentEofCanceled() + 1);
    }

    void incrementFaultAckLimit(U8 chanId) {
        FW_ASSERT(chanId < Cfdp::NumChannels, chanId);
        m_channelTelemetry[chanId].set_faultAckLimit(m_channelTelemetry[chanId].get_faultAckLimit() + 1);
    }

    void incrementFaultNakLimit(U8 chanId) {
        FW_ASSERT(chanId < Cfdp::NumChannels, chanId);
        m_channelTelemetry[chanId].set_faultNakLimit(m_channelTelemetry[chanId].get_faultNakLimit() + 1);
    }

    void incrementFaultInactivityTimer(U8 chanId) {
        FW_ASSERT(chanId < Cfdp::NumChannels, chanId);
        m_channelTelemetry[chanId].set_faultInactivityTimer(m_channelTelemetry[chanId].get_faultInactivityTimer() + 1);
    }

    void incrementFaultCrcMismatch(U8 chanId) {
        FW_ASSERT(chanId < Cfdp::NumChannels, chanId);
        m_channelTelemetry[chanId].set_faultCrcMismatch(m_channelTelemetry[chanId].get_faultCrcMismatch() + 1);
    }

    void incrementFaultFileSizeMismatch(U8 chanId) {
        FW_ASSERT(chanId < Cfdp::NumChannels, chanId);
        m_channelTelemetry[chanId].set_faultFileSizeMismatch(m_channelTelemetry[chanId].get_faultFileSizeMismatch() +
                                                             1);
    }

    void incrementFaultFileOpen(U8 chanId) {
        FW_ASSERT(chanId < Cfdp::NumChannels, chanId);
        m_channelTelemetry[chanId].set_faultFileOpen(m_channelTelemetry[chanId].get_faultFileOpen() + 1);
    }

    void incrementFaultFileRead(U8 chanId) {
        FW_ASSERT(chanId < Cfdp::NumChannels, chanId);
        m_channelTelemetry[chanId].set_faultFileRead(m_channelTelemetry[chanId].get_faultFileRead() + 1);
    }

    void incrementFaultFileWrite(U8 chanId) {
        FW_ASSERT(chanId < Cfdp::NumChannels, chanId);
        m_channelTelemetry[chanId].set_faultFileWrite(m_channelTelemetry[chanId].get_faultFileWrite() + 1);
    }

    void incrementFaultFileSeek(U8 chanId) {
        FW_ASSERT(chanId < Cfdp::NumChannels, chanId);
        m_channelTelemetry[chanId].set_faultFileSeek(m_channelTelemetry[chanId].get_faultFileSeek() + 1);
    }

    void incrementFaultFileRename(U8 chanId) {
        FW_ASSERT(chanId < Cfdp::NumChannels, chanId);
        m_channelTelemetry[chanId].set_faultFileRename(m_channelTelemetry[chanId].get_faultFileRename() + 1);
    }

    void incrementFaultDirectoryRead(U8 chanId) {
        FW_ASSERT(chanId < Cfdp::NumChannels, chanId);
        m_channelTelemetry[chanId].set_faultDirectoryRead(m_channelTelemetry[chanId].get_faultDirectoryRead() + 1);
    }

    void incrementFaultRxEofError(U8 chanId) {
        FW_ASSERT(chanId < Cfdp::NumChannels, chanId);
        m_channelTelemetry[chanId].set_faultRxEofError(m_channelTelemetry[chanId].get_faultRxEofError() + 1);
    }

    void incrementFaultTxEofError(U8 chanId) {
        FW_ASSERT(chanId < Cfdp::NumChannels, chanId);
        m_channelTelemetry[chanId].set_faultTxEofError(m_channelTelemetry[chanId].get_faultTxEofError() + 1);
    }

    Cfdp::ChannelTelemetry& getChannelTelemetryRef(U8 chanId) {
        FW_ASSERT(chanId < Cfdp::NumChannels, chanId);
        return m_channelTelemetry[chanId];
    }

  private:
    // ----------------------------------------------------------------------
    // Handler implementations for typed input ports
    // ----------------------------------------------------------------------

    void run1Hz_handler(FwIndexType portNum,  
                        U32 context           
                        ) override;

    void dataReturnIn_handler(FwIndexType portNum,  
                              Fw::Buffer& fwBuffer) override;

    void dataIn_handler(FwIndexType portNum,  
                        Fw::Buffer& fwBuffer  
                        ) override;

    Svc::SendFileResponse fileIn_handler(FwIndexType portNum,                   
                                         const Fw::StringBase& sourceFileName,  
                                         const Fw::StringBase& destFileName,    
                                         U32 offset,                            
                                         U32 length  
                                         ) override;

    void pingIn_handler(FwIndexType portNum,  
                        U32 key               
                        ) override;

  private:
    // ----------------------------------------------------------------------
    // Handler implementations for commands
    // ----------------------------------------------------------------------

    void SendFile_cmdHandler(FwOpcodeType opCode,     
                             U32 cmdSeq,              
                             U8 channelId,            
                             EntityId destId,         
                             const Class& cfdpClass,  
                             const Keep& keep,        
                             U8 priority,             
                             const Fw::CmdStringArg& sourceFileName,  
                             const Fw::CmdStringArg& destFileName  
                             ) override;

    void PlaybackDirectory_cmdHandler(
        FwOpcodeType opCode,                      
        U32 cmdSeq,                               
        U8 channelId,                             
        EntityId destId,                          
        const Class& cfdpClass,                   
        const Keep& keep,                         
        U8 priority,                              
        const Fw::CmdStringArg& sourceDirectory,  
        const Fw::CmdStringArg& destDirectory     
        ) override;

    void PollDirectory_cmdHandler(
        FwOpcodeType opCode,                      
        U32 cmdSeq,                               
        U8 channelId,                             
        U8 pollId,                                
        EntityId destId,                          
        const Class& cfdpClass,                   
        U8 priority,                              
        U32 interval,                             
        const Fw::CmdStringArg& sourceDirectory,  
        const Fw::CmdStringArg& destDirectory     
        ) override;

    void StopPollDirectory_cmdHandler(FwOpcodeType opCode,  
                                      U32 cmdSeq,           
                                      U8 channelId,         
                                      U8 pollId             
                                      ) override;

    void SetChannelFlow_cmdHandler(FwOpcodeType opCode,  
                                   U32 cmdSeq,           
                                   U8 channelId,         
                                   const Flow& freeze    
                                   ) override;

    void SuspendResumeTransaction_cmdHandler(FwOpcodeType opCode,            
                                             U32 cmdSeq,                     
                                             U8 channelId,                   
                                             TransactionSeq transactionSeq,  
                                             EntityId entityId,              
                                             const SuspendResume& action     
                                             ) override;

    void CancelTransaction_cmdHandler(FwOpcodeType opCode,            
                                      U32 cmdSeq,                     
                                      U8 channelId,                   
                                      TransactionSeq transactionSeq,  
                                      EntityId entityId               
                                      ) override;

    void AbandonTransaction_cmdHandler(FwOpcodeType opCode,            
                                       U32 cmdSeq,                     
                                       U8 channelId,                   
                                       TransactionSeq transactionSeq,  
                                       EntityId entityId               
                                       ) override;

    void ResetCounters_cmdHandler(FwOpcodeType opCode,  
                                  U32 cmdSeq,           
                                  U8 channelId          
                                  ) override;

  private:
    // ----------------------------------------------------------------------
    // Private command helper functions
    // ----------------------------------------------------------------------

    void drainFileInQueue();

    Fw::CmdResponse::T checkCommandChannelIndex(U8 channelIndex  
    );

    Fw::CmdResponse::T checkCommandChannelPollIndex(U8 pollIndex  
    );

    Fw::CmdResponse::T checkCommandPollInterval(U32 interval  
    );

  public:
    // ----------------------------------------------------------------------
    // Parameter helpers used by the CFDP engine
    // ----------------------------------------------------------------------

    EntityId getLocalEidParam(void);

    U32 getOutgoingFileChunkSizeParam(void);

    U32 getRxCrcCalcBytesPerCycleParam(void);

    U8 getPostInactivitySendRetriesParam(void);

    Fw::String getTmpDirParam(U8 channelIndex);

    Fw::String getFailDirParam(U8 channelIndex);

    U8 getAckLimitParam(U8 channelIndex);

    U8 getNackLimitParam(U8 channelIndex);

    U32 getAckTimerParam(U8 channelIndex);

    U32 getInactivityTimerParam(U8 channelIndex);

    Fw::Enabled getDequeueEnabledParam(U8 channelIndex);

    Fw::String getMoveDirParam(U8 channelIndex);

    U32 getMaxOutgoingPdusPerCycleParam(U8 channelIndex);

  private:
    // ----------------------------------------------------------------------
    // Types
    // ----------------------------------------------------------------------

    struct FileInRequest {
        Fw::String sourceFileName;  
        Fw::String destFileName;    
        U32 context;                
    };

    // ----------------------------------------------------------------------
    // Member variables
    // ----------------------------------------------------------------------
    // CFDP Engine - owns all protocol state and operations
    Engine* m_engine;

    Os::Queue m_fileInQueue;

    FwSizeType m_fileInQueueDepth = 0;

    Cfdp::ChannelTelemetryArray m_channelTelemetry;

    FwEnumStoreType m_allocatorId = 0;
    Fw::MemAllocator* m_allocator = nullptr;
};

}  // namespace Cfdp
}  // namespace Ccsds
}  // namespace Svc

#endif  // CCSDS_CFDPMANAGER_HPP