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 <config/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 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() {
            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 {

        friend class FileDownlinkTester;

        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 {

        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);

        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 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 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 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;
    };

} // end namespace Svc

#endif