FileDownlink.hpp

Go to the documentation of this file.

// ======================================================================
// \title  FileDownlink.hpp
// \author bocchino, mstarch
// \brief  hpp file for FileDownlink component implementation class
//
// \copyright
// Copyright 2009-2015, by the California Institute of Technology.
// ALL RIGHTS RESERVED.  United States Government Sponsorship
// acknowledged.
// ======================================================================

#ifndef Svc_FileDownlink_HPP
#define Svc_FileDownlink_HPP

#include <Fw/FilePacket/FilePacket.hpp>
#include <Fw/Types/FileNameString.hpp>
#include <Os/File.hpp>
#include <Os/Mutex.hpp>
#include <Os/Queue.hpp>
#include <Os/SandboxedFile.hpp>
#include <Svc/FileDownlink/FileDownlinkComponentAc.hpp>
#include <config/FileDownlinkCfg.hpp>

namespace Svc {

class FileDownlink final : public FileDownlinkComponentBase {
    friend class FileDownlinkTester;

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

    class Mode {
        friend class FileDownlinkTester;

      public:
        typedef enum { IDLE, DOWNLINK, CANCEL, WAIT, COOLDOWN } Type;

      public:
        Mode() : m_value(IDLE) {}

      public:
        void set(const Type value) {
            this->m_mutex.lock();
            this->m_value = value;
            this->m_mutex.unLock();
        }

        Type get() const {
            this->m_mutex.lock();
            const Type value = this->m_value;
            this->m_mutex.unLock();
            return value;
        }

      private:
        Type m_value;

        mutable Os::Mutex m_mutex;
    };

    class File {
        friend class FileDownlinkTester;

      public:
        File() : m_size(0) {}

      private:
        Fw::LogStringArg m_sourceName;

        Fw::LogStringArg m_destName;

        Os::SandboxedFile m_osFile;

        U32 m_size;

        CFDP::Checksum m_checksum;

      public:
        Os::File::Status open(const Fw::FileNameString& sourceFileName,  
                              const Fw::FileNameString& destFileName     
        );

        Os::File::Status read(U8* const data, const U32 byteOffset, const U32 size);

        void getChecksum(CFDP::Checksum& checksum) { checksum = this->m_checksum; }

        Fw::LogStringArg& getSourceName(void) { return this->m_sourceName; }

        Fw::LogStringArg& getDestName(void) { return this->m_destName; }

        void configureSandbox(const char* directory) { this->m_osFile.configure(directory); }

        Os::SandboxedFile& getOsFile(void) { return this->m_osFile; }

        U32 getSize(void) { return this->m_size; }
    };

    class FilesSent {
        friend class FileDownlinkTester;

      public:
        FilesSent(FileDownlink* const fileDownlink) : m_sent_file_count(0), m_fileDownlink(fileDownlink) {}

      public:
        void fileSent() {
            ++this->m_sent_file_count;
            this->m_fileDownlink->tlmWrite_FilesSent(m_sent_file_count);
        }

      private:
        U32 m_sent_file_count;

        FileDownlink* const m_fileDownlink;
    };

    class PacketsSent {
        friend class FileDownlinkTester;

      public:
        PacketsSent(FileDownlink* const fileDownlink) : m_sent_packet_count(0), m_fileDownlink(fileDownlink) {}

      public:
        void packetSent() {
            ++this->m_sent_packet_count;
            this->m_fileDownlink->tlmWrite_PacketsSent(m_sent_packet_count);
        }

      private:
        U32 m_sent_packet_count;

        FileDownlink* const m_fileDownlink;
    };

    class Warnings {
        friend class FileDownlinkTester;

      public:
        Warnings(FileDownlink* const fileDownlink) : m_warning_count(0), m_fileDownlink(fileDownlink) {}

      public:
        void fileOpenError();

        void fileRead(const Os::File::Status status);

        void zeroSize();

        void sourceOutOfSandbox();

      private:
        void warning() {
            ++this->m_warning_count;
            this->m_fileDownlink->tlmWrite_Warnings(m_warning_count);
        }

      private:
        U32 m_warning_count;

        FileDownlink* const m_fileDownlink;
    };

    enum CallerSource { COMMAND, PORT };

    struct FileEntry {
        Fw::FileNameString srcFilename;   // Name of requested file
        Fw::FileNameString destFilename;  // Name of requested file
        U32 offset;
        U32 length;
        CallerSource source;  // Source of the downlink request
        FwOpcodeType opCode;  // Op code of command, only set for CMD sources.
        U32 cmdSeq;           // CmdSeq number, only set for CMD sources.
        U32 context;          // Context id of request, only set for PORT sources.
    };

    enum PacketType { FILE_PACKET, CANCEL_PACKET, COUNT_PACKET_TYPE };

  public:
    // ----------------------------------------------------------------------
    // Construction, initialization, and destruction
    // ----------------------------------------------------------------------

    FileDownlink(const char* const compName  
    );

    void configure(U32 cooldown,       
                   U32 cycleTime,      
                   U32 fileQueueDepth  
    );

    void configure(const char* directory);

    void deinit();

    void preamble();

    ~FileDownlink();

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

    void Run_handler(const FwIndexType portNum,  
                     U32 context                 
    );

    Svc::SendFileResponse SendFile_handler(
        const FwIndexType portNum,            
        const Fw::StringBase& sourceFilename, 
        const Fw::StringBase& destFilename,   
        U32 offset, 
        U32 length  
    );

    void bufferReturn_handler(const FwIndexType portNum,  
                              Fw::Buffer& fwBuffer);

    void pingIn_handler(const FwIndexType portNum, 
                        U32 key                    
    );

  private:
    // ----------------------------------------------------------------------
    // Command handler implementations
    // ----------------------------------------------------------------------

    void SendFile_cmdHandler(const FwOpcodeType opCode,               
                             const U32 cmdSeq,                        
                             const Fw::CmdStringArg& sourceFilename,  
                             const Fw::CmdStringArg& destFilename  
    );

    void Cancel_cmdHandler(const FwOpcodeType opCode,  
                           const U32 cmdSeq            
    );

    void SendPartial_cmdHandler(
        FwOpcodeType opCode,                     
        U32 cmdSeq,                              
        const Fw::CmdStringArg& sourceFilename,  
        const Fw::CmdStringArg& destFilename,    
        U32 startOffset,                         
        U32 length  
    );

  private:
    // ----------------------------------------------------------------------
    // Private helper methods
    // ----------------------------------------------------------------------

    void sendFile(
        const Fw::FileNameString& sourceFilename,  
        const Fw::FileNameString& destFilename,    
        U32 startOffset,                           
        U32 length  
    );

    // Individual packet transfer functions
    Os::File::Status sendDataPacket(U32& byteOffset);
    void sendCancelPacket();
    void sendEndPacket();
    void sendStartPacket();
    void sendFilePacket(const Fw::FilePacket& filePacket);

    // State-helper functions
    void exitFileTransfer();
    void enterCooldown();

    // Function to acquire a buffer internally
    void getBuffer(Fw::Buffer& buffer, PacketType type);
    // Downlink the "next" packet
    void downlinkPacket();
    // Finish the file transfer
    void finishHelper(bool is_cancel);
    // Convert internal status enum to a command response
    Fw::CmdResponse statusToCmdResp(SendFileStatus status);
    // Send response after completing file downlink
    void sendResponse(SendFileStatus resp);

  private:
    // ----------------------------------------------------------------------
    // Member variables
    // ----------------------------------------------------------------------

    bool m_configured;

    Os::Queue m_fileQueue;

    U8 m_memoryStore[COUNT_PACKET_TYPE][FILEDOWNLINK_INTERNAL_BUFFER_SIZE];

    Mode m_mode;

    File m_file;

    FilesSent m_filesSent;

    PacketsSent m_packetsSent;

    Warnings m_warnings;

    U32 m_sequenceIndex;

    U32 m_timeout;

    U32 m_cooldown;

    U32 m_curTimer;

    U32 m_cycleTime;

    Fw::Buffer m_buffer;

    U32 m_bufferSize;

    U32 m_byteOffset;

    U32 m_endOffset;

    Fw::FilePacket::Type m_lastCompletedType;

    U32 m_lastBufferId;

    struct FileEntry m_curEntry;

    U32 m_cntxId;
};

}  // end namespace Svc

#endif