node_monitor.h

Go to the documentation of this file.

// Monitors a single node process
// Author: Max Schwarz <max.schwarz@uni-bonn.de>

#ifndef ROSMON_MONITOR_NODE_MONITOR_H
#define ROSMON_MONITOR_NODE_MONITOR_H

#include "../launch/node.h"
#include "../fd_watcher.h"

#include <ros/node_handle.h>

#include <boost/signals2.hpp>
#include <boost/circular_buffer.hpp>

namespace rosmon
{

namespace monitor
{

class NodeMonitor
{
public:
        typedef std::shared_ptr<NodeMonitor> Ptr;
        typedef std::shared_ptr<NodeMonitor> ConstPtr;

        enum State
        {
                STATE_IDLE,    
                STATE_RUNNING, 
                STATE_CRASHED, 
                STATE_WAITING  
        };

        NodeMonitor(
                launch::Node::ConstPtr launchNode,
                FDWatcher::Ptr fdWatcher, ros::NodeHandle& nh);
        ~NodeMonitor();



        void start();

        void stop(bool restart = false);

        void restart();

        void shutdown();

        void forceExit();

        bool running() const;

        State state() const;



        inline bool coredumpAvailable() const
        { return !m_debuggerCommand.empty(); }

        inline std::string debuggerCommand() const
        { return m_debuggerCommand; }

        void launchDebugger();



        void beginStatUpdate();
        void addCPUTime(uint64_t userTime, uint64_t systemTime);
        void addMemory(uint64_t memoryBytes);
        void endStatUpdate(uint64_t elapsedTime);

        inline double userLoad() const
        { return m_userLoad; }

        inline double systemLoad() const
        { return m_systemLoad; }

        inline double memory() const
        { return m_memory; }

        inline unsigned int restartCount() const
        { return m_restartCount; }

    inline uint64_t memoryLimit()const
    { return m_launchNode->memoryLimitByte();}

    inline float cpuLimit()const
    { return m_launchNode->cpuLimit();}


        inline std::string name() const
        { return m_launchNode->name(); }

        inline std::string namespaceString() const
        { return m_launchNode->namespaceString(); }

        inline int pid() const
        { return m_pid; }

        inline double stopTimeout() const
        { return m_launchNode->stopTimeout(); }

        boost::signals2::signal<void(std::string,std::string)> logMessageSignal;

        boost::signals2::signal<void(std::string)> exitedSignal;
private:
        enum Command
        {
                CMD_RUN,
                CMD_STOP,
                CMD_RESTART
        };

        std::vector<std::string> composeCommand() const;

        void communicate();

        template<typename... Args>
        void log(const char* format, const Args& ... args);
        void checkStop();
        void gatherCoredump(int signal);

        launch::Node::ConstPtr m_launchNode;

        FDWatcher::Ptr m_fdWatcher;

        boost::circular_buffer<char> m_rxBuffer;

        int m_pid = -1;
        int m_fd = -1;
        int m_exitCode;

        ros::WallTimer m_stopCheckTimer;
        ros::WallTimer m_restartTimer;

        Command m_command;

        bool m_restarting;

        std::string m_debuggerCommand;

        unsigned int m_restartCount = 0;

        uint64_t m_userTime = 0;
        uint64_t m_systemTime = 0;
        double m_userLoad = 0.0;
        double m_systemLoad = 0.0;
        uint64_t m_memory = 0;

        std::string m_processWorkingDirectory;
        bool m_processWorkingDirectoryCreated = false;
};

}

}

#endif