MHO_Snapshot.hh

Go to the documentation of this file.

#ifndef MHO_Snapshot_HH__
#define MHO_Snapshot_HH__
 
#include <cstdlib>
#include <iostream>
#include <ostream>
#include <set>
#include <sstream>
#include <string>
#include <unistd.h>
 
//global messaging util
#include "MHO_Message.hh"
 
//handles reading directories, listing files etc.
#include "MHO_DirectoryInterface.hh"
 
//needed to read hops files and extract objects
#include "MHO_ContainerDefinitions.hh"
#include "MHO_ContainerDictionary.hh"
#include "MHO_ContainerFileInterface.hh"
#include "MHO_ContainerStore.hh"
 
namespace hops
{
 
//
//TODO make this class thread safe
class MHO_Snapshot
{
 
    public:
        //since this is a singleton we need to remove ability to copy/move
        MHO_Snapshot(MHO_Snapshot const&) = delete;
        MHO_Snapshot(MHO_Snapshot&&) = delete;
        MHO_Snapshot& operator=(MHO_Snapshot const&) = delete;
        MHO_Snapshot& operator=(MHO_Snapshot&&) = delete;
 
        // @brief Returns the directory into which snapshot files are written:
        // <install_prefix>/snapshot, resolved at runtime via
        // MHO_DirectoryInterface::GetHopsInstallPrefix(). Falls back to "." (the
        // current directory) if the install prefix cannot be determined, so that
        // no absolute install path is baked into the binary..
        static std::string GetSnapshotDirectory()
        {
            std::string prefix = MHO_DirectoryInterface::GetHopsInstallPrefix();
            if(prefix.empty())
            {
                msg_warn("snapshot",
                         "could not determine HOPS install prefix; writing snapshot files to the current directory" << eom);
                return std::string(".");
            }
            return prefix + "/snapshot";
        }
 
        static MHO_Snapshot& GetInstance()
        {
            static MHO_Snapshot instance;
            return instance;
        }
 
        void SetExecutableName(std::string exe_name) { fExeName = exe_name; };
 
        void AcceptAllKeys() { fAcceptAllKeys = true; }
 
        void LimitToKeySet() { fAcceptAllKeys = false; }
 
        void AddKey(const std::string& key);
        void RemoveKey(const std::string& key);
        void RemoveAllKeys();
 
        template< typename XObjType > void DumpObject(XObjType* obj, const char* key, const char* name)
        {
            DumpObject(obj, std::string(key), std::string(name));
        }
 
        template< typename XObjType > void DumpObject(XObjType* obj, std::string key, std::string name)
        {
            if(PassSnapshot(key))
            {
                std::string output_file = fPrefix + fExeName + fPostfix;
                MHO_BinaryFileInterface inter;
                bool status = inter.OpenToAppend(output_file);
 
                std::cout << "dump to file: " << output_file << std::endl;
 
                if(status)
                {
                    inter.Write(*obj, name);
                    fCountLabel++;
                }
                else
                {
                    msg_error("file", "error writing object " << name << " to file: " << output_file << eom);
                }
                inter.Close();
            }
        }
 
        template< typename XObjType >
        void DumpObject(XObjType* obj, std::string key, std::string name, std::string file, int line)
        {
            if(PassSnapshot(key))
            {
                std::string output_file = fPrefix + fExeName + fPostfix;
                MHO_BinaryFileInterface inter;
                bool status = inter.OpenToAppend(output_file);
 
                msg_debug("snapshot", "dumping object (" << name << ") snapshot to file: " << output_file << eom);
 
                if(status)
                {
                    obj->Insert(std::string("name"), name);
                    obj->Insert(std::string("snapshot_key"), key);
                    obj->Insert(std::string("executable"), fExeName);
                    obj->Insert(std::string("file"), file);
                    obj->Insert(std::string("line"), line);
                    obj->Insert(std::string("count_label"), (int)fCountLabel);
                    inter.Write(*obj, name);
                    fCountLabel++;
                }
                else
                {
                    msg_error("file", "error writing object " << name << " to file: " << output_file << eom);
                }
                inter.Close();
            }
        }
 
    private:
        int GetPID()
        {
            pid_t pid = getpid();
            return (int)pid;
        }
 
        //no public access to constructor
        //set up the directory where we dump snapshots
        MHO_Snapshot(): fCurrentKeyIsAllowed(false), fAcceptAllKeys(false)
        {
            std::string dir_string = GetSnapshotDirectory();
 
            //dump data into a file for later inspection
            std::stringstream ss;
            ss << ".pid";
            ss << GetPID();
 
            fPrefix = dir_string + "/";
            fPostfix = ss.str() + ".snap";
            fExeName = "";
        };
 
        virtual ~MHO_Snapshot(){};
 
        bool PassSnapshot(std::string key);
 
        //used to construct filename in which to dump snapshots
        int fPID;
        std::string fPrefix;
        std::string fPostfix;
        std::string fExeName;
 
        //label is used to count the number of snapshots we have dumped
        uint32_t fCountLabel;
 
        std::set< std::string > fKeys; //keys of which messages we will accept for output
        bool fCurrentKeyIsAllowed;     //current key is in allowed set
        bool fAcceptAllKeys;
};
 
//this is defined as a compiler flag via build system
#ifdef HOPS_ENABLE_SNAPSHOTS
    //allow object snapshots to be dumped when enabled
    #define take_snapshot(xKEY, xNAME, xOBJECT) MHO_Snapshot::GetInstance().DumpObject(xOBJECT, xKEY, xNAME);
    #define take_snapshot_here(xKEY, xNAME, xFILE, xLINE, xOBJECT)                                                             \
        MHO_Snapshot::GetInstance().DumpObject(xOBJECT, xKEY, xNAME, xFILE, xLINE);
 
#else
    //snapshot not enables, define to nothing
    #define take_snapshot(xKEY, xNAME, xOBJECT)
    #define take_snapshot_here(xKEY, xNAME, xFILE, xLINE, xOBJECT)
#endif
 
} // namespace hops
 
#endif