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 "../launch/launch_config.h"
#include "../fd_watcher.h"
#include "../log_event.h"
#include "log_parser.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(
                const launch::LaunchConfig::ConstPtr& config,
                const 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(double elapsedTimeInTicks);
 
        inline double userLoad() const
        { return m_userLoad; }
 
        inline double systemLoad() const
        { return m_systemLoad; }
 
        inline uint64_t memory() const
        { return m_memory; }
 
        inline unsigned int restartCount() const
        { return m_restartCount; }
 
        inline int numRespawnsAllowed() const
        { return m_launchNode->numRespawnsAllowed(); }
 
        inline uint64_t memoryLimit() const
        { return m_launchNode->memoryLimitByte();}
 
        inline double 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 std::string fullName() const
        {
                return namespaceString() + "/" + name();
        }
 
        inline int pid() const
        { return m_pid; }
 
        inline double stopTimeout() const
        { return m_launchNode->stopTimeout(); }
 
        void setMuted(bool muted);
 
        bool isMuted() const
        { return m_muted; }
 
        boost::signals2::signal<void(LogEvent)> 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();
        void communicateStderr();
 
        template<typename... Args>
        void log(const char* format, Args&& ... args);
 
        template<typename... Args>
        void logTyped(LogEvent::Type type, const char* format, Args&& ... args);
 
        void checkStop();
        void gatherCoredump(int signal);
 
        std::pair<int,int> createPTY();
 
        launch::LaunchConfig::ConstPtr m_launchConfig;
        launch::Node::ConstPtr m_launchNode;
 
        FDWatcher::Ptr m_fdWatcher;
 
        LogParser m_stdoutParser;
        LogParser m_stderrParser;
 
        int m_pid = -1;
        int m_fd = -1;
        int m_stderrFD = -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;
        std::string m_lastWorkingDirectory;
        bool m_processWorkingDirectoryCreated = false;
 
        bool m_firstStart = true;
 
        bool m_muted = false;
};
 
}
 
}
 
#endif