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 <FileDownlinkCfg.hpp>
#include <Svc/FileDownlink/FileDownlinkComponentAc.hpp>
#include <Fw/FilePacket/FilePacket.hpp>
#include <Os/File.hpp>
#include <Os/Mutex.hpp>
#include <Os/Queue.hpp>
 
 
namespace Svc {
 
  class FileDownlink :
    public FileDownlinkComponentBase
  {
 
    PRIVATE:
 
      // ----------------------------------------------------------------------
      // Types
      // ----------------------------------------------------------------------
 
      class Mode {
 
        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() {
            this->m_mutex.lock();
            const Type value = this->m_value;
            this->m_mutex.unLock();
            return value;
          }
 
        private:
 
          Type m_value;
 
          Os::Mutex m_mutex;
      };
 
      class File {
 
        public:
 
          File() : m_size(0) { }
 
        PRIVATE:
 
          Fw::LogStringArg m_sourceName;
 
          Fw::LogStringArg m_destName;
 
          Os::File m_osFile;
 
          U32 m_size;
 
          CFDP::Checksum m_checksum;
 
        public:
 
          Os::File::Status open(
              const char *const sourceFileName, 
              const char *const 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;
          }
 
          Os::File& getOsFile(void) {
            return this->m_osFile;
          }
 
          U32 getSize(void) {
            return this->m_size;
          }
      };
 
      class FilesSent {
 
        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 {
 
        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 {
 
        public:
 
          Warnings(FileDownlink *const fileDownlink) :
            m_warning_count(0),
            m_fileDownlink(fileDownlink)
          { }
 
        public:
 
          void fileOpenError();
 
          void fileRead(const Os::File::Status status);
 
        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 };
 
      #define FILE_ENTRY_FILENAME_LEN 101
 
      struct FileEntry {
        char srcFilename[FILE_ENTRY_FILENAME_LEN]; // Name of requested file
        char destFilename[FILE_ENTRY_FILENAME_LEN]; // 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 init(
          const NATIVE_INT_TYPE queueDepth, 
          const NATIVE_INT_TYPE instance 
      );
 
      void configure(
          U32 timeout, 
          U32 cooldown, 
          U32 cycleTime, 
          U32 fileQueueDepth 
      );
 
      void preamble();
 
      ~FileDownlink();
 
    PRIVATE:
 
      // ----------------------------------------------------------------------
      // Handler implementations for user-defined typed input ports
      // ----------------------------------------------------------------------
 
      void Run_handler(
          const NATIVE_INT_TYPE portNum, 
          NATIVE_UINT_TYPE context 
      );
 
 
      Svc::SendFileResponse SendFile_handler(
          const NATIVE_INT_TYPE portNum, 
          const sourceFileNameString& sourceFilename, 
          const destFileNameString& destFilename, 
          U32 offset, 
          U32 length 
      );
 
      void bufferReturn_handler(
          const NATIVE_INT_TYPE portNum, 
          Fw::Buffer &fwBuffer
      );
 
      void pingIn_handler(
          const NATIVE_INT_TYPE 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 char* sourceFilename, 
          const char* 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;
    };
  class FileDownlink : {…};
 
} // end namespace Svc
 
#endif