BufferLogger.hpp

Go to the documentation of this file.

// ======================================================================
// \title  BufferLogger.hpp
// \author bocchino, dinkel, mereweth
// \brief  Svc Buffer Logger interface
//
// \copyright
// Copyright (C) 2015-2017 California Institute of Technology.
// ALL RIGHTS RESERVED.  United States Government Sponsorship
// acknowledged.
//
// ======================================================================

#ifndef Svc_BufferLogger_HPP
#define Svc_BufferLogger_HPP

#include "Fw/Types/Assert.hpp"
#include "Fw/Types/String.hpp"
#include "Os/File.hpp"
#include "Os/Mutex.hpp"
#include "Svc/BufferLogger/BufferLoggerComponentAc.hpp"
#include "Utils/Hash/Hash.hpp"

namespace Svc {

// Forward declaration for UTs
namespace Logging {
class CloseFileTester;
class SendBuffersTester;
class OnOffTester;
}  // namespace Logging
namespace Errors {
class BufferLoggerTester;
}

class BufferLogger final : public BufferLoggerComponentBase {
    friend class BufferLoggerTester;
    friend class Svc::Logging::CloseFileTester;
    friend class Svc::Logging::SendBuffersTester;
    friend class Svc::Logging::OnOffTester;
    friend class Svc::Errors::BufferLoggerTester;

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

    class File {
        friend class BufferLoggerTester;
        friend class Svc::Logging::CloseFileTester;
        friend class Svc::Logging::SendBuffersTester;
        friend class Svc::Logging::OnOffTester;
        friend class Svc::Errors::BufferLoggerTester;

      public:
        struct Mode {
            typedef enum { CLOSED = 0, OPEN = 1 } t;
        };

      public:
        File(BufferLogger& bufferLogger  
        );

        ~File();

      public:
        void init(const char* const prefix,  
                  const char* const suffix,  
                  const FwSizeType maxSize,  
                  const U8 sizeOfSize  
        );

        void setBaseName(const Fw::ConstStringBase&
                             baseName  
        );

        void logBuffer(const U8* const data,  
                       const FwSizeType size  
        );

        void closeAndEmitEvent();

        bool flush();

      private:
        void open();

        bool writeBuffer(const U8* const data,  
                         const FwSizeType size  
        );

        bool writeSize(const FwSizeType size  
        );

        bool writeBytes(const void* const data,  
                        const FwSizeType length  
        );

        void writeHashFile();

        void close();

      private:
        BufferLogger& m_bufferLogger;

        Fw::String m_prefix;

        Fw::String m_suffix;

        Fw::String m_baseName;

        FwSizeType m_fileCounter;

        FwSizeType m_maxSize;

        U8 m_sizeOfSize;

        Fw::String m_name;

        // The current mode
        Mode::t m_mode;

        Os::File m_osFile;

        FwSizeType m_bytesWritten;

        Utils::Hash m_hash;

    };  // class File

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

    BufferLogger(const char* const compName 
    );

    // ----------------------------------------------------------------------
    // Public methods
    // ----------------------------------------------------------------------

    void initLog(
        const char* const logFilePrefix,  
        const char* const logFileSuffix,  
        const FwSizeType maxFileSize,     
        const U8 sizeOfSize  
    );

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

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

    void comIn_handler(const FwIndexType portNum,  
                       Fw::ComBuffer& data,        
                       U32 context                 
    );

    void pingIn_handler(const FwIndexType portNum,  
                        U32 key                     
    );

    void schedIn_handler(const FwIndexType portNum, 
                         U32 context                
    );

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

    void BL_OpenFile_cmdHandler(const FwOpcodeType opCode, 
                                const U32 cmdSeq,          
                                const Fw::CmdStringArg& file);

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

    void BL_SetLogging_cmdHandler(const FwOpcodeType opCode, 
                                  const U32 cmdSeq,          
                                  const BufferLogger_LogState& state);

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

  private:
    // ----------------------------------------------------------------------
    // Private instance variables
    // ----------------------------------------------------------------------

    BufferLogger_LogState m_state;

    File m_file;
};

}  // namespace Svc

#endif