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