FileUplink.hpp

Go to the documentation of this file.

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

#ifndef Svc_FileUplink_HPP
#define Svc_FileUplink_HPP

#include <Fw/FilePacket/FilePacket.hpp>
#include <Os/File.hpp>
#include <Os/SandboxedFile.hpp>
#include <Svc/FileUplink/FileUplinkComponentAc.hpp>

namespace Svc {

class FileUplink final : public FileUplinkComponentBase {
    friend class FileUplinkTester;

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

    typedef enum { START, DATA } ReceiveMode;

    class File {
        friend class FileUplinkTester;

      public:
        U32 size;

        Fw::LogStringArg name;

        Os::SandboxedFile osFile;

      private:
        ::CFDP::Checksum m_checksum;

      public:
        Os::File::Status open(const Fw::FilePacket::StartPacket& startPacket);

        Os::File::Status write(const U8* const data, const U32 byteOffset, const U32 length);

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

    class FilesReceived {
        friend class FileUplinkTester;

      public:
        FilesReceived(FileUplink* const fileUplink) : m_received_files_counter(0), m_fileUplink(fileUplink) {}

      public:
        void fileReceived() {
            ++this->m_received_files_counter;
            this->m_fileUplink->tlmWrite_FilesReceived(m_received_files_counter);
        }

      private:
        U32 m_received_files_counter;

        FileUplink* const m_fileUplink;
    };

    class FilesReceivedFailed {
        friend class FileUplinkTester;

      public:
        FilesReceivedFailed(FileUplink* const fileUplink) : m_failed_files_counter(0), m_fileUplink(fileUplink) {}

      public:
        void fileReceivedFailed() {
            ++this->m_failed_files_counter;
            this->m_fileUplink->tlmWrite_FilesReceivedFailed(m_failed_files_counter);
        }

      private:
        U32 m_failed_files_counter;

        FileUplink* const m_fileUplink;
    };

    class PacketsReceived {
        friend class FileUplinkTester;

      public:
        PacketsReceived(FileUplink* const fileUplink) : m_received_packet_count(0), m_fileUplink(fileUplink) {}

      public:
        void packetReceived() {
            ++this->m_received_packet_count;
            this->m_fileUplink->tlmWrite_PacketsReceived(m_received_packet_count);
        }

      private:
        U32 m_received_packet_count;

        FileUplink* const m_fileUplink;
    };

    class Warnings {
        friend class FileUplinkTester;

      public:
        Warnings(FileUplink* const fileUplink) : m_warning_count(0), m_fileUplink(fileUplink) {}

      public:
        void invalidReceiveMode(const Fw::FilePacket::Type packetType);

        void fileOpen(Fw::LogStringArg& fileName);

        void packetOutOfBounds(const U32 sequenceIndex, Fw::LogStringArg& fileName);

        void packetOutOfOrder(const U32 sequenceIndex, const U32 lastSequenceIndex);

        void packetDuplicate(const U32 sequenceIndex);

        void fileWrite(Fw::LogStringArg& fileName);

        void badChecksum(const U32 computed, const U32 read);

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

      private:
        U32 m_warning_count;

        FileUplink* const m_fileUplink;
    };

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

    FileUplink(const char* const name  
    );

    ~FileUplink();

    void configure(const char* directory);

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

    void bufferSendIn_handler(const FwIndexType portNum,  
                              Fw::Buffer& buffer          
    );

    void pingIn_handler(const FwIndexType portNum, 
                        U32 key                    
    );

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

    void handleStartPacket(const Fw::FilePacket::StartPacket& startPacket);

    void handleDataPacket(const Fw::FilePacket::DataPacket& dataPacket);

    void handleEndPacket(const Fw::FilePacket::EndPacket& endPacket);

    void handleCancelPacket();

    void checkSequenceIndex(const U32 sequenceIndex);

    bool checkDuplicatedPacket(const U32 sequenceIndex);

    bool compareChecksums(const Fw::FilePacket::EndPacket& endPacket);

    void goToStartMode();

    void goToDataMode();

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

    ReceiveMode m_receiveMode;

    U32 m_lastSequenceIndex;

    Os::File::Status m_lastPacketWriteStatus;

    File m_file;

    FilesReceived m_filesReceived;

    FilesReceivedFailed m_filesReceivedFailed;

    PacketsReceived m_packetsReceived;

    Warnings m_warnings;
};

}  // namespace Svc

#endif