mirror of
https://github.com/mariadb-corporation/mariadb-columnstore-engine.git
synced 2025-05-30 00:27:08 +03:00
578 lines
12 KiB
C++
578 lines
12 KiB
C++
/* Copyright (C) 2014 InfiniDB, Inc.
|
|
|
|
This program is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU General Public License
|
|
as published by the Free Software Foundation; version 2 of
|
|
the License.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
|
|
MA 02110-1301, USA. */
|
|
|
|
/***************************************************************************
|
|
* $Id: processmonitor.h 1993 2013-04-04 18:33:48Z rdempsey $
|
|
*
|
|
***************************************************************************/
|
|
|
|
|
|
#ifndef _PROCESSMONITOR_H_
|
|
#define _PROCESSMONITOR_H_
|
|
|
|
#include <string>
|
|
#include <sys/shm.h>
|
|
#include <sys/wait.h>
|
|
#include <errno.h>
|
|
|
|
#include "liboamcpp.h"
|
|
#include "shmkeys.h"
|
|
#include "alarmglobal.h"
|
|
#include "socketclosed.h"
|
|
|
|
namespace processmonitor {
|
|
|
|
#define INIT_SUPPORT 0 // 0 = 'INIT -0' COMMAND COMPILED IN, 1 = 'INIT -0' COMMANDS COMPILED OUT
|
|
|
|
#define MAXARGUMENTS 15
|
|
#define MAXDEPENDANCY 6
|
|
|
|
/**
|
|
* @brief processStructure Process Config Structure
|
|
*/
|
|
typedef struct processStructure
|
|
{
|
|
std::string ProcessModuleType;
|
|
std::string ProcessName;
|
|
std::string ProcessLocation;
|
|
std::string ProcessArgs[MAXARGUMENTS];
|
|
time_t currentTime;
|
|
uint16_t launchID;
|
|
pid_t processID;
|
|
uint16_t state;
|
|
uint16_t BootLaunch;
|
|
uint16_t dieCounter;
|
|
std::string RunType;
|
|
std::string DepProcessName[MAXDEPENDANCY];
|
|
std::string DepModuleName[MAXDEPENDANCY];
|
|
std::string LogFile;
|
|
} processInfo;
|
|
|
|
typedef std::vector<processInfo> processList;
|
|
|
|
|
|
/**
|
|
* @brief shmProcessStatus Process Status Structure
|
|
*/
|
|
struct shmProcessStatus
|
|
{
|
|
pid_t ProcessID; //!< Process ID number
|
|
char StateChangeDate[24]; //!< Last time/date state change
|
|
uint16_t ProcessOpState; //!< Process Operational State
|
|
};
|
|
|
|
/**
|
|
* @brief processStatus Process Status Structure
|
|
*/
|
|
typedef struct processStatus
|
|
{
|
|
std::string ProcessName;
|
|
std::string ModuleName;
|
|
uint16_t tableIndex;
|
|
} processstatus;
|
|
|
|
typedef std::vector<processstatus> processStatusList;
|
|
|
|
/**
|
|
* @brief shmDeviceStatus Status Structure
|
|
*/
|
|
#define NAMESIZE 128
|
|
#define DATESIZE 24
|
|
|
|
struct shmDeviceStatus
|
|
{
|
|
char Name[NAMESIZE]; //!< Device Name
|
|
char StateChangeDate[DATESIZE]; //!< Last time/date state change
|
|
uint16_t OpState; //!< Device Operational State
|
|
};
|
|
|
|
|
|
/**
|
|
* @brief MonitorConfig class builds a list of process it starts
|
|
*
|
|
*/
|
|
class MonitorConfig
|
|
{
|
|
public:
|
|
/**
|
|
* @brief constructor
|
|
*
|
|
*/
|
|
MonitorConfig();
|
|
/**
|
|
* @brief destructor
|
|
*
|
|
*/
|
|
~MonitorConfig();
|
|
|
|
/**
|
|
* moduleName accessor
|
|
*/
|
|
const std::string& moduleName() const
|
|
{
|
|
return flocalModuleName;
|
|
}
|
|
|
|
/**
|
|
* moduleType accessor
|
|
*/
|
|
const std::string& moduleType() const
|
|
{
|
|
return flocalModuleType;
|
|
}
|
|
|
|
/**
|
|
* moduleName accessor
|
|
*/
|
|
const uint16_t& moduleID() const
|
|
{
|
|
return flocalModuleID;
|
|
}
|
|
|
|
/**
|
|
* parentName accessor
|
|
*/
|
|
const std::string& OAMParentName() const
|
|
{
|
|
return fOAMParentModuleName;
|
|
}
|
|
|
|
/**
|
|
* parentFlag accessor
|
|
*/
|
|
const bool& OAMParentFlag() const
|
|
{
|
|
return fOAMParentModuleFlag;
|
|
}
|
|
|
|
/**
|
|
* ServerInstallType accessor
|
|
*/
|
|
const uint16_t& ServerInstallType() const
|
|
{
|
|
return fserverInstallType;
|
|
}
|
|
|
|
/**
|
|
* StandbyName accessor
|
|
*/
|
|
const std::string& OAMStandbyName() const
|
|
{
|
|
return fOAMStandbyModuleName;
|
|
}
|
|
|
|
/**
|
|
* standbyParentFlag accessor
|
|
*/
|
|
const bool& OAMStandbyParentFlag() const
|
|
{
|
|
return fOAMStandbyModuleFlag;
|
|
}
|
|
|
|
/**
|
|
* SoftwareVersion accessor
|
|
*/
|
|
const std::string& SoftwareVersion() const
|
|
{
|
|
return fsoftwareVersion;
|
|
}
|
|
|
|
/**
|
|
* SoftwareRelease accessor
|
|
*/
|
|
const std::string& SoftwareRelease() const
|
|
{
|
|
return fsoftwareRelease;
|
|
}
|
|
|
|
/**
|
|
* Build a list of processes the monitor started
|
|
*/
|
|
void buildList(std::string ProcessModuleType,
|
|
std::string processName,
|
|
std::string ProcessLocation,
|
|
std::string arg_list[MAXARGUMENTS],
|
|
uint16_t launchID,
|
|
pid_t processID,
|
|
uint16_t state,
|
|
uint16_t BootLaunch,
|
|
std::string RunType,
|
|
std::string DepProcessName[MAXDEPENDANCY],
|
|
std::string DepModuleName[MAXDEPENDANCY],
|
|
std::string logFile);
|
|
|
|
/**
|
|
* return the process list
|
|
*/
|
|
processList* monitoredListPtr();
|
|
|
|
/**
|
|
* return the process ID
|
|
*/
|
|
|
|
void findProcessInfo (pid_t processID, processInfo& info);
|
|
|
|
/**
|
|
* @brief copy constructor
|
|
*
|
|
*/
|
|
MonitorConfig(const MonitorConfig& rhs);
|
|
/**
|
|
* @brief copy assignment operator
|
|
*
|
|
*/
|
|
MonitorConfig& operator=(const MonitorConfig& rhs);
|
|
|
|
|
|
private:
|
|
std::string flocalModuleName;
|
|
std::string flocalModuleType;
|
|
uint16_t flocalModuleID;
|
|
std::string fOAMParentModuleName;
|
|
bool fOAMParentModuleFlag;
|
|
uint16_t fserverInstallType;
|
|
std::string fOAMStandbyModuleName;
|
|
bool fOAMStandbyModuleFlag;
|
|
|
|
processList fmonitoredListPtr;
|
|
std::string fsoftwareVersion;
|
|
std::string fsoftwareRelease;
|
|
};
|
|
|
|
/**
|
|
* @brief MonitorLog class logs the activities between Process Monitor
|
|
* and its child processes for debugging purpose.
|
|
*/
|
|
class MonitorLog
|
|
{
|
|
public:
|
|
/**
|
|
* Constructor:open the log file for writing
|
|
*/
|
|
MonitorLog();
|
|
|
|
/**
|
|
* Destructor:close the log file
|
|
*/
|
|
~MonitorLog();
|
|
|
|
/**
|
|
* @brief Write the message to the log
|
|
*/
|
|
void writeLog(const int lineNumber, const std::string logContent, const logging::LOG_TYPE logType = logging::LOG_TYPE_INFO);
|
|
|
|
/**
|
|
* @brief Write the message to the log
|
|
*/
|
|
void writeLog(const int lineNumber, const int logContent, const logging::LOG_TYPE logType = logging::LOG_TYPE_INFO);
|
|
|
|
|
|
private:
|
|
std::ofstream logFile;
|
|
/**
|
|
* @brief copy constructor
|
|
*
|
|
*/
|
|
MonitorLog(const MonitorLog& rhs);
|
|
/**
|
|
* @brief copy assignment operator
|
|
*
|
|
*/
|
|
MonitorLog& operator=(const MonitorLog& rhs);
|
|
|
|
};
|
|
|
|
|
|
/**
|
|
* @brief ProcessMonitor class takes requests from Process Manager for
|
|
* starting, stopping, and restarting processes. It monitors the processes it started,
|
|
* logs its events, and restarts the died processes.
|
|
*/
|
|
class ProcessMonitor
|
|
{
|
|
public:
|
|
/**
|
|
* Constructor
|
|
*/
|
|
ProcessMonitor(MonitorConfig &config, MonitorLog &log);
|
|
|
|
/**
|
|
* Default Destructor
|
|
*/
|
|
~ProcessMonitor();
|
|
/**
|
|
* Start a process
|
|
*/
|
|
pid_t startProcess(std::string processModuleType, std::string processName, std::string processLocation,
|
|
std::string arg_list[MAXARGUMENTS], uint16_t launchID, uint16_t BootLaunch,
|
|
std::string RunType, std::string DepProcessName[MAXDEPENDANCY] ,
|
|
std::string DepModuleName[MAXDEPENDANCY], std::string LogFile, uint16_t startType,
|
|
uint16_t actIndicator = oam::FORCEFUL);
|
|
|
|
/**
|
|
* get Alarm Data and send to requester
|
|
*/
|
|
int getAlarmData(messageqcpp::IOSocket mq, int type, std::string date);
|
|
|
|
/**
|
|
* Stop a process
|
|
*/
|
|
int stopProcess(pid_t processID, std::string processName, std::string processLocation, int actionIndicator, bool manualFlag);
|
|
|
|
/**
|
|
* Re-init a process
|
|
*/
|
|
int reinitProcess(pid_t processID, std::string processName, int actionIndicator);
|
|
|
|
/**
|
|
* Stop all processes started by this monitor
|
|
*/
|
|
int stopAllProcess(int actionIndicator);
|
|
|
|
/**
|
|
* receive and process message
|
|
*/
|
|
void processMessage(messageqcpp::ByteStream msg, messageqcpp::IOSocket mq);
|
|
|
|
/**
|
|
* send message to the monitored process or the process manager
|
|
*/
|
|
int sendMessage(const std::string& toWho, const std::string& message);
|
|
|
|
/**
|
|
* check child process heart beat
|
|
*/
|
|
int checkHeartBeat(const std::string processName);
|
|
|
|
/**
|
|
* send a trap and log the process information
|
|
*/
|
|
void sendAlarm(std::string alarmItem, oam::ALARMS alarmID, int action);
|
|
|
|
/**
|
|
*@brief update process disk state
|
|
*/
|
|
bool updateProcessInfo(std::string processName, int state, pid_t pid);
|
|
|
|
/**
|
|
*@brief update log configuration
|
|
*/
|
|
int updateLog(std::string action, std::string level);
|
|
|
|
/**
|
|
*@brief get log configuration
|
|
*/
|
|
int getConfigLog();
|
|
|
|
/**
|
|
*@brief change Log File priviledges
|
|
*/
|
|
void changeModLog();
|
|
|
|
/**
|
|
*@brief check Power-On Test results
|
|
*/
|
|
void checkPowerOnResults();
|
|
|
|
/**
|
|
*@brief update Config
|
|
*/
|
|
int updateConfig();
|
|
|
|
/**
|
|
*@brief build System Tables
|
|
*/
|
|
int buildSystemTables();
|
|
|
|
/**
|
|
*@brief configure Module fucntionality
|
|
*/
|
|
int configureModule(std::string configureModuleName);
|
|
|
|
/**
|
|
*@brief reconfigure Module fucntionality
|
|
*/
|
|
int reconfigureModule(std::string reconfigureModuleName);
|
|
|
|
/**
|
|
*@brief check Single Process State
|
|
*/
|
|
int checkSpecialProcessState( std::string processName, std::string runType, std::string processModuleType );
|
|
|
|
/**
|
|
*@brief Check if Mate Module is Active
|
|
*/
|
|
int checkMateModuleState();
|
|
|
|
/**
|
|
*@brief Create the Calpont Data directories
|
|
*/
|
|
|
|
int createDataDirs(std::string cloud);
|
|
|
|
/**
|
|
*@brief Process Restarted, inform Process Mgr
|
|
*/
|
|
|
|
int processRestarted( std::string processName, bool manual = true );
|
|
|
|
/**
|
|
*@brief update crontab to have logs archived at midnight
|
|
*/
|
|
|
|
int changeCrontab();
|
|
|
|
/**
|
|
*@brief Update Transaction Log
|
|
*/
|
|
|
|
int changeTransactionLog();
|
|
|
|
/**
|
|
*@brief update Core Dump configuration
|
|
*/
|
|
int updateCore(std::string action);
|
|
|
|
/**
|
|
*@brief setup Tranaction Logging
|
|
*/
|
|
void setTransactionLog(bool action);
|
|
|
|
/**
|
|
*@brief Remove XM ProcMon setup
|
|
*/
|
|
int removeXMProcMon();
|
|
|
|
/**
|
|
*@brief unmount from associated system
|
|
*/
|
|
int umountSystem();
|
|
|
|
/**
|
|
*@brief Runs DB sanity test
|
|
*/
|
|
int runStartupTest();
|
|
|
|
/**
|
|
*@brief Runs HDFS sanity test
|
|
*/
|
|
int runHDFSTest();
|
|
|
|
/**
|
|
*@brief Update Calpont Config File
|
|
*/
|
|
int updateConfigFile(messageqcpp::ByteStream msg);
|
|
|
|
int getDBRMdata();
|
|
|
|
/**
|
|
*@brief Send Msg to Process Monitor
|
|
*/
|
|
std::string sendMsgProcMon1( std::string module, messageqcpp::ByteStream msg, int requestID );
|
|
|
|
/**
|
|
*@brief check if module failover is needed due to a process outage
|
|
*/
|
|
void checkProcessFailover( std::string processName);
|
|
|
|
/**
|
|
*@brief run upgrade script
|
|
*/
|
|
int runUpgrade(std::string mysqlpw);
|
|
|
|
/**
|
|
*@brief change my.cnf
|
|
*/
|
|
int changeMyCnf(std::string type);
|
|
|
|
/**
|
|
*@brief run Master Replication script
|
|
*/
|
|
int runMasterRep(std::string& masterLogFile, std::string& masterLogPos);
|
|
|
|
/**
|
|
*@brief run Master Distribution
|
|
*/
|
|
int runMasterDist(std::string& password, std::string& slaveModule);
|
|
|
|
/**
|
|
*@brief run Slave Replication script
|
|
*/
|
|
int runSlaveRep(std::string& masterLogFile, std::string& masterLogPos, std::string& port);
|
|
|
|
/**
|
|
*@brief run Disable Replication script
|
|
*/
|
|
|
|
int runDisableRep();
|
|
|
|
/**
|
|
*@brief Amazon Instance and IP check
|
|
*/
|
|
bool amazonIPCheck();
|
|
|
|
/**
|
|
*@brief UnMOunt any extra dbroots
|
|
*/
|
|
void unmountExtraDBroots();
|
|
|
|
/**
|
|
*@brief Calculate TotalUmMemory
|
|
*/
|
|
void calTotalUmMemory();
|
|
|
|
/**
|
|
*@brief Amazon Volume check
|
|
*/
|
|
bool amazonVolumeCheck(int dbrootID = 0);
|
|
|
|
/**
|
|
*@brief Check Data Mounts
|
|
*/
|
|
int checkDataMount();
|
|
|
|
/** @brief flush inode cache
|
|
*/
|
|
void flushInodeCache();
|
|
|
|
/** @brief glusterAssign
|
|
*/
|
|
int glusterAssign(std::string dbrootID);
|
|
|
|
/** @brief glusterUnassign
|
|
*/
|
|
int glusterUnassign(std::string dbrootID);
|
|
|
|
/**
|
|
* return the process list
|
|
*/
|
|
// processStatusList* statusListPtr();
|
|
|
|
// processStatusList fstatusListPtr;
|
|
|
|
private:
|
|
/*need define copy ans assignment constructor */
|
|
MonitorConfig &config;
|
|
MonitorLog &log;
|
|
};
|
|
|
|
} //end of namespace
|
|
|
|
|
|
|
|
#endif // _PROCESSMONITOR_H_
|