void test2() {
SystemModuleTypeConfig systemmoduletypeconfig;
Oam oamapi;
oamapi.getSystemConfig(systemmoduletypeconfig);
for( unsigned int i = 0 ; i < systemmoduletypeconfig.moduletypeconfig.size(); i++)
{
if( systemmoduletypeconfig.moduletypeconfig[i].ModuleType.empty() )
// end of list
break;
Svalue = systemmoduletypeconfig.moduletypeconfig[i].ModuleType;
CPPUNIT_ASSERT(!Svalue.empty());
Svalue = systemmoduletypeconfig.moduletypeconfig[i].ModuleDesc;
CPPUNIT_ASSERT(!Svalue.empty());
Ivalue = systemmoduletypeconfig.moduletypeconfig[i].ModuleCount;
CPPUNIT_ASSERT(Ivalue != -1);
Ivalue = systemmoduletypeconfig.moduletypeconfig[i].ModuleCPUCriticalThreshold;
CPPUNIT_ASSERT(Ivalue != -1);
Ivalue = systemmoduletypeconfig.moduletypeconfig[i].ModuleCPUMajorThreshold;
CPPUNIT_ASSERT(Ivalue != -1);
Ivalue = systemmoduletypeconfig.moduletypeconfig[i].ModuleCPUMinorThreshold;
CPPUNIT_ASSERT(Ivalue != -1);
Ivalue = systemmoduletypeconfig.moduletypeconfig[i].ModuleCPUMinorClearThreshold;
CPPUNIT_ASSERT(Ivalue != -1);
}
};
void test10() {
Oam oamapi;
oamapi.setSystemConfig("ModuleCPUMajorThreshold1", 7500);
oamapi.getSystemConfig("ModuleCPUMajorThreshold1", Ivalue);
CPPUNIT_ASSERT(Ivalue == 7500);
};
void test8() {
Oam oamapi;
oamapi.setSystemConfig("ModuleHeartbeatPeriod", 5);
oamapi.getSystemConfig("ModuleHeartbeatPeriod", Ivalue);
CPPUNIT_ASSERT(Ivalue == 5);
};
void test5() {
Oam oamapi;
oamapi.setSystemConfig("SystemVersion", "V2.0.2.3");
oamapi.getSystemConfig("SystemVersion", Svalue);
CPPUNIT_ASSERT(Svalue == "V2.0.2.3");
};
/* void test3() {
ModuleConfig moduleconfig;
const string Modulename = "dm1";
Oam oamapi;
oamapi.getSystemConfig(Modulename, moduleconfig);
Svalue = moduleconfig.ModuleName;
CPPUNIT_ASSERT(!Svalue.empty());
};
*/
void test4() {
ModuleConfig moduleconfig;
Oam oamapi;
oamapi.getSystemConfig(moduleconfig);
Svalue = moduleconfig.ModuleName;
CPPUNIT_ASSERT(!Svalue.empty());
};
/**
* Constructors/Destructors
*/
PredicateOperator::PredicateOperator()
{
Oam oam;
// get and set locale language
string systemLang = "C";
try
{
oam.getSystemConfig("SystemLang", systemLang);
}
catch (...)
{}
if ( systemLang != "en_US.UTF-8" &&
systemLang.find("UTF") != string::npos )
futf8 = true;
}
void test1() {
SystemConfig systemconfig;
Oam oamapi;
oamapi.getSystemConfig(systemconfig);
Ivalue = systemconfig.ModuleHeartbeatPeriod;
CPPUNIT_ASSERT(Ivalue != -1);
Ivalue = systemconfig.ModuleHeartbeatCount;
CPPUNIT_ASSERT(Ivalue != -1);
// Ivalue = systemconfig.ProcessHeartbeatPeriod;
// CPPUNIT_ASSERT(Ivalue != -2);
Svalue = systemconfig.NMSIPAddr;
CPPUNIT_ASSERT(!Svalue.empty());
};
/*****************************************************************************************
* @brief diskMonitor Thread
*
* purpose: Get current Local and External disk usage and report alarms
*
*****************************************************************************************/
void diskMonitor()
{
ServerMonitor serverMonitor;
Oam oam;
SystemConfig systemConfig;
ModuleTypeConfig moduleTypeConfig;
typedef std::vector<std::string> LocalFileSystems;
LocalFileSystems lfs;
struct statvfs buf;
// set defaults
int localDiskCritical = 90,
localDiskMajor = 80,
localDiskMinor = 70,
ExternalDiskCritical = 90,
ExternalDiskMajor = 80,
ExternalDiskMinor = 70;
// get module types
string moduleType;
int moduleID=-1;
string moduleName;
oamModuleInfo_t t;
try {
t = oam.getModuleInfo();
moduleType = boost::get<1>(t);
moduleID = boost::get<2>(t);
moduleName = boost::get<0>(t);
}
catch (exception& e) {}
bool Externalflag = false;
//check for external disk
DBrootList dbrootList;
if (moduleType == "pm") {
systemStorageInfo_t t;
t = oam.getStorageConfig();
if ( boost::get<0>(t) == "external")
Externalflag = true;
// get dbroot list and storage type from config file
DBRootConfigList dbrootConfigList;
oam.getPmDbrootConfig(moduleID, dbrootConfigList);
DBRootConfigList::iterator pt = dbrootConfigList.begin();
for( ; pt != dbrootConfigList.end() ; pt++)
{
int dbrootID = *pt;
string dbroot = "DBRoot" + oam.itoa(dbrootID);
string dbootdir;
try{
oam.getSystemConfig(dbroot, dbootdir);
}
catch(...) {}
if ( dbootdir.empty() || dbootdir == "" )
continue;
DBrootData dbrootData;
dbrootData.dbrootDir = dbootdir;
dbrootData.downFlag = false;
dbrootList.push_back(dbrootData);
}
}
string cloud = oam::UnassignedName;
try {
oam.getSystemConfig( "Cloud", cloud);
}
catch(...) {
cloud = oam::UnassignedName;
}
//get Gluster Config setting
string GlusterConfig = "n";
try {
oam.getSystemConfig( "GlusterConfig", GlusterConfig);
}
catch(...)
{
GlusterConfig = "n";
}
int diskSpaceCheck = 0;
while(true)
{
SystemStatus systemstatus;
try {
oam.getSystemStatus(systemstatus);
}
catch (exception& ex)
{}
if (systemstatus.SystemOpState != oam::ACTIVE ) {
sleep(5);
continue;
}
// Get Local/External Disk Mount points to monitor and associated thresholds
try {
oam.getSystemConfig (moduleTypeConfig);
localDiskCritical = moduleTypeConfig.ModuleDiskCriticalThreshold;
localDiskMajor = moduleTypeConfig.ModuleDiskMajorThreshold;
localDiskMinor = moduleTypeConfig.ModuleDiskMinorThreshold;
DiskMonitorFileSystems::iterator p = moduleTypeConfig.FileSystems.begin();
for( ; p != moduleTypeConfig.FileSystems.end() ; p++)
{
string fs = *p;
lfs.push_back(fs);
if (DISK_DEBUG) {
//Log this event
LoggingID lid(SERVER_MONITOR_LOG_ID);
MessageLog ml(lid);
Message msg;
Message::Args args;
args.add("Local Config File System to monitor =");
args.add(fs);
msg.format(args);
ml.logDebugMessage(msg);
}
}
} catch (...)
{
sleep(5);
continue;
}
// get External info
try
{
oam.getSystemConfig(systemConfig);
} catch (...)
{
sleep(5);
continue;
}
if (Externalflag) {
// get External info
try
{
ExternalDiskCritical = systemConfig.ExternalCriticalThreshold;
ExternalDiskMajor = systemConfig.ExternalMajorThreshold;
ExternalDiskMinor = systemConfig.ExternalMinorThreshold;
} catch (...)
{
sleep(5);
continue;
}
}
//check for local file systems
LocalFileSystems::iterator p = lfs.begin();
while(p != lfs.end())
{
string deviceName = *p;
++p;
string fileName;
// check local
if ( deviceName == "/") {
fileName = deviceName + "usr/local/Calpont/releasenum";
}
else
{
fileName = deviceName + "/000.dir";
}
uint64_t totalBlocks;
uint64_t usedBlocks;
if (!statvfs(fileName.c_str(), &buf)) {
uint64_t blksize, blocks, freeblks, free;
blksize = buf.f_bsize;
blocks = buf.f_blocks;
freeblks = buf.f_bfree;
totalBlocks = blocks * blksize;
free = freeblks * blksize;
usedBlocks = totalBlocks - free;
}
else
continue;
int64_t diskUsage = 0;
if ( totalBlocks == 0 ) {
diskUsage = 0;
//Log this event
LoggingID lid(SERVER_MONITOR_LOG_ID);
MessageLog ml(lid);
Message msg;
Message::Args args;
args.add("Total Disk Usage is set to 0");
msg.format(args);
ml.logWarningMessage(msg);
}
else
diskUsage = (usedBlocks / (totalBlocks / 100)) + 1;
SMSystemDisk sd;
sd.deviceName = deviceName;
sd.usedPercent = diskUsage;
sd.totalBlocks = totalBlocks;
sd.usedBlocks = usedBlocks;
sdl.push_back(sd);
if (DISK_DEBUG)
cout << "Disk Usage for " << deviceName << " is " << diskUsage << endl;
if ( diskSpaceCheck == 0 )
{
if (diskUsage >= localDiskCritical && localDiskCritical > 0 ) {
//adjust if over 100%
if ( diskUsage > 100 )
diskUsage = 100;
if ( serverMonitor.sendResourceAlarm(deviceName, DISK_USAGE_HIGH, SET, (int) diskUsage) )
{
LoggingID lid(SERVER_MONITOR_LOG_ID);
MessageLog ml(lid);
Message msg;
Message::Args args;
args.add("Local Disk above Critical Disk threshold with a percentage of ");
args.add((int) diskUsage);
msg.format(args);
ml.logInfoMessage(msg);
}
}
else if (diskUsage >= localDiskMajor && localDiskMajor > 0 ) {
if (serverMonitor.sendResourceAlarm(deviceName, DISK_USAGE_MED, SET, (int) diskUsage))
{
LoggingID lid(SERVER_MONITOR_LOG_ID);
MessageLog ml(lid);
Message msg;
Message::Args args;
args.add("Local Disk above Major Disk threshold with a percentage of ");
args.add((int) diskUsage);
msg.format(args);
ml.logInfoMessage(msg);
}
}
else if (diskUsage >= localDiskMinor && localDiskMinor > 0 ) {
if ( serverMonitor.sendResourceAlarm(deviceName, DISK_USAGE_LOW, SET, (int) diskUsage))
{
LoggingID lid(SERVER_MONITOR_LOG_ID);
MessageLog ml(lid);
Message msg;
Message::Args args;
args.add("Local Disk above Minor Disk threshold with a percentage of ");
args.add((int) diskUsage);
msg.format(args);
ml.logInfoMessage(msg);
}
}
else
serverMonitor.checkDiskAlarm(deviceName);
}
//check for external file systems/devices
if (Externalflag ||
(!Externalflag && GlusterConfig == "y" && moduleType == "pm") ){
try
{
DBRootConfigList dbrootConfigList;
oam.getPmDbrootConfig(moduleID, dbrootConfigList);
DBRootConfigList::iterator pt = dbrootConfigList.begin();
for( ; pt != dbrootConfigList.end() ; pt++)
{
int dbroot = *pt;
string deviceName = systemConfig.DBRoot[dbroot-1];
string fileName = deviceName + "/000.dir";
if (DISK_DEBUG) {
//Log this event
LoggingID lid(SERVER_MONITOR_LOG_ID);
MessageLog ml(lid);
Message msg;
Message::Args args;
args.add("DBRoots monitoring");
args.add(dbroot);
args.add(" ,file system =" );
args.add(fileName);
msg.format(args);
ml.logDebugMessage(msg);
}
uint64_t totalBlocks;
uint64_t usedBlocks;
if (!statvfs(fileName.c_str(), &buf)) {
uint64_t blksize, blocks, freeblks, free;
blksize = buf.f_bsize;
blocks = buf.f_blocks;
freeblks = buf.f_bfree;
totalBlocks = blocks * blksize;
free = freeblks * blksize;
usedBlocks = totalBlocks - free;
}
else
{
SMSystemDisk sd;
sd.deviceName = deviceName;
sd.usedPercent = 0;
sd.totalBlocks = 0;
sd.usedBlocks = 0;
sdl.push_back(sd);
continue;
}
int diskUsage = 0;
if ( totalBlocks == 0 ) {
diskUsage = 0;
//Log this event
LoggingID lid(SERVER_MONITOR_LOG_ID);
MessageLog ml(lid);
Message msg;
Message::Args args;
args.add("Total Disk Usage is set to 0");
msg.format(args);
ml.logWarningMessage(msg);
}
else
diskUsage = (usedBlocks / (totalBlocks / 100)) + 1;
SMSystemDisk sd;
sd.deviceName = deviceName;
sd.usedPercent = diskUsage;
sd.totalBlocks = totalBlocks;
sd.usedBlocks = usedBlocks;
sdl.push_back(sd);
if (DISK_DEBUG)
cout << "Disk Usage for " << deviceName << " is " << diskUsage << endl;
if (diskUsage >= ExternalDiskCritical && ExternalDiskCritical > 0 ) {
//adjust if over 100%
if ( diskUsage > 100 )
diskUsage = 100;
if ( serverMonitor.sendResourceAlarm(deviceName, DISK_USAGE_HIGH, SET, diskUsage))
{
LoggingID lid(SERVER_MONITOR_LOG_ID);
MessageLog ml(lid);
Message msg;
Message::Args args;
args.add("Disk usage for");
args.add(deviceName);
args.add(" above Critical Disk threshold with a percentage of ");
args.add((int) diskUsage);
msg.format(args);
ml.logInfoMessage(msg);
}
}
else if (diskUsage >= ExternalDiskMajor && ExternalDiskMajor > 0 ) {
if ( serverMonitor.sendResourceAlarm(deviceName, DISK_USAGE_MED, SET, diskUsage))
{
LoggingID lid(SERVER_MONITOR_LOG_ID);
MessageLog ml(lid);
Message msg;
Message::Args args;
args.add("Disk usage for");
args.add(deviceName);
args.add(" above Major Disk threshold with a percentage of ");
args.add((int) diskUsage);
msg.format(args);
ml.logInfoMessage(msg);
}
}
else if (diskUsage >= ExternalDiskMinor && ExternalDiskMinor > 0 ) {
if ( serverMonitor.sendResourceAlarm(deviceName, DISK_USAGE_LOW, SET, diskUsage))
{
LoggingID lid(SERVER_MONITOR_LOG_ID);
MessageLog ml(lid);
Message msg;
Message::Args args;
args.add("Disk usage for");
args.add(deviceName);
args.add(" above Minor Disk threshold with a percentage of ");
args.add((int) diskUsage);
msg.format(args);
ml.logInfoMessage(msg);
}
}
else
serverMonitor.checkDiskAlarm(deviceName);
}
}
catch (exception& e)
{
cout << endl << "**** getPmDbrootConfig Failed : " << e.what() << endl;
}
}
}
//check OAM dbroot test flag to validate dbroot exist if on pm
if ( moduleName.find("pm") != string::npos ) {
//check OAM dbroot test flag to validate dbroot exist
if ( dbrootList.size() != 0 ) {
DBrootList::iterator p = dbrootList.begin();
while ( p != dbrootList.end() )
{
//get dbroot directory
string dbrootDir = (*p).dbrootDir;
string dbrootName;
string dbrootID;
//get dbroot name
string::size_type pos = dbrootDir.rfind("/",80);
if (pos != string::npos)
dbrootName = dbrootDir.substr(pos+1,80);
//get ID
dbrootID = dbrootName.substr(4,80);
string fileName = dbrootDir + "/OAMdbrootCheck";
// retry in case we hit the remount window
for ( int retry = 0 ; ; retry++ )
{
bool fail = false;
//first test, check if OAMdbrootCheck exists
ifstream file (fileName.c_str());
if (!file)
fail = true;
else
{ //second test for amazon, check volume status
if ( cloud != oam::UnassignedName ) {
string volumeNameID = "PMVolumeName" + dbrootID;
string volumeName = oam::UnassignedName;
try {
oam.getSystemConfig( volumeNameID, volumeName);
}
catch(...)
{}
if ( volumeName.empty() || volumeName == oam::UnassignedName )
fail = false;
else
{
string status = oam.getEC2VolumeStatus(volumeName);
if ( status == "attached" )
fail = false;
else
{
fail = true;
LoggingID lid(SERVER_MONITOR_LOG_ID);
MessageLog ml(lid);
Message msg;
Message::Args args;
args.add("dbroot monitoring: Volume not attached");
args.add(volumeName);
args.add("/");
args.add(dbrootName);
msg.format(args);
ml.logCriticalMessage(msg);
}
}
}
else
fail = false;
}
if (fail) {
//double check system status before reporting any error BUG 5078
SystemStatus systemstatus;
try {
oam.getSystemStatus(systemstatus);
}
catch (exception& ex)
{}
if (systemstatus.SystemOpState != oam::ACTIVE ) {
break;
}
if ( retry < 10 ) {
sleep(3);
continue;
}
else
{
if ( !(*p).downFlag ) {
LoggingID lid(SERVER_MONITOR_LOG_ID);
MessageLog ml(lid);
Message msg;
Message::Args args;
args.add("dbroot monitoring: Lost access to ");
args.add(dbrootDir);
msg.format(args);
ml.logCriticalMessage(msg);
oam.sendDeviceNotification(dbrootName, DBROOT_DOWN, moduleName);
(*p).downFlag = true;
try{
oam.setDbrootStatus(dbrootID, oam::AUTO_OFFLINE);
}
catch (exception& ex)
{}
break;
}
}
}
else
{
if ( (*p).downFlag ) {
LoggingID lid(SERVER_MONITOR_LOG_ID);
MessageLog ml(lid);
Message msg;
Message::Args args;
args.add("dbroot monitoring: Access back to ");
args.add(dbrootDir);
msg.format(args);
ml.logInfoMessage(msg);
oam.sendDeviceNotification(dbrootName, DBROOT_UP, moduleName);
(*p).downFlag = false;
try{
oam.setDbrootStatus(dbrootID, oam::ACTIVE);
}
catch (exception& ex)
{}
}
file.close();
break;
}
}
p++;
}
}
}
//do Gluster status check, if configured
if ( GlusterConfig == "y")
{
bool pass = true;
string errmsg = "unknown";
try {
string arg1 = "";
string arg2 = "";
int ret = oam.glusterctl(oam::GLUSTER_STATUS, arg1, arg2, errmsg);
if ( ret != 0 )
{
cerr << "FAILURE: Status check error: " + errmsg << endl;
pass = false;
}
}
catch (exception& e)
{
cerr << endl << "**** glusterctl API exception: " << e.what() << endl;
cerr << "FAILURE: Status check error" << endl;
pass = false;
}
catch (...)
{
cerr << endl << "**** glusterctl API exception: UNKNOWN" << endl;
cerr << "FAILURE: Status check error" << endl;
pass = false;
}
if ( !pass )
{ // issue log and alarm
LoggingID lid(SERVER_MONITOR_LOG_ID);
MessageLog ml(lid);
Message msg;
Message::Args args;
args.add("Gluster Status check failure error msg: ");
args.add(errmsg);
msg.format(args);
ml.logWarningMessage(msg);
serverMonitor.sendResourceAlarm(errmsg, GLUSTER_DISK_FAILURE, SET, 0);
}
}
// sleep 10 seconds
sleep(MONITOR_PERIOD/6);
//check disk space every 10 minutes
diskSpaceCheck++;
if ( diskSpaceCheck >= 60 )
diskSpaceCheck = 0;
lfs.clear();
sdl.clear();
} // end of while loop
}
int main(int argc, char *argv[])
{
setenv("CALPONT_HOME", "./", 1);
Oam oam;
string systemParentOAMModuleName;
string parentOAMModuleIPAddr;
PerformanceModuleList performancemodulelist;
int pmNumber = 0;
string prompt;
int DBRMworkernodeID = 0;
string remote_installer_debug = "0";
Config* sysConfigOld;
Config* sysConfigNew;
string systemName;
bool extextMapCheckOnly = false;
if (argc > 1) {
string arg1 = argv[1];
if ( arg1 == "-e" )
extextMapCheckOnly = true;
else
systemName = arg1;
}
else
systemName = oam::UnassignedName;
try {
sysConfigOld = Config::makeConfig("./Calpont.xml");
sysConfigNew = Config::makeConfig("./Calpont.xml.new");
}
catch(...)
{
cout << "ERROR: Problem reading Calpont.xml files";
exit(-1);
}
string SystemSection = "SystemConfig";
string InstallSection = "Installation";
//set install config flag
try {
sysConfigNew->setConfig(InstallSection, "InitialInstallFlag", "y");
}
catch(...)
{
cout << "ERROR: Problem setting InitialInstallFlag from the Calpont System Configuration file" << endl;
exit(-1);
}
//read cloud parameter to see if this is a 3.0 or pre-3.0 build
string cloud;
try {
cloud = sysConfigOld->getConfig(InstallSection, "Cloud");
}
catch(...)
{ }
bool build3 = false;
if ( !cloud.empty() )
build3 = true;
//set install config flag
try {
sysConfigNew->setConfig(InstallSection, "InitialInstallFlag", "y");
}
catch(...)
{
cout << "ERROR: Problem setting InitialInstallFlag from the Calpont System Configuration file" << endl;
exit(-1);
}
//set gluster flag if it exists
string GlusterConfig;
string GlusterCopies;
string GlusterStorageType;
try {
GlusterConfig = sysConfigOld->getConfig(InstallSection, "GlusterConfig");
GlusterCopies = sysConfigOld->getConfig(InstallSection, "GlusterCopies");
GlusterStorageType = sysConfigOld->getConfig(InstallSection, "GlusterStorageType");
}
catch(...)
{}
if ( !GlusterConfig.empty() ) {
try {
sysConfigNew->setConfig(InstallSection, "GlusterConfig", GlusterConfig);
sysConfigNew->setConfig(InstallSection, "GlusterCopies", GlusterCopies);
sysConfigNew->setConfig(InstallSection, "GlusterStorageType", GlusterStorageType);
}
catch(...)
{}
}
//check and make sure the ExtentMap variables don't get changed at install
string oldFilesPerColumnPartition;
string oldExtentsPerSegmentFile;
string newFilesPerColumnPartition;
string newExtentsPerSegmentFile;
try {
oldFilesPerColumnPartition = sysConfigOld->getConfig("ExtentMap", "FilesPerColumnPartition");
oldExtentsPerSegmentFile = sysConfigOld->getConfig("ExtentMap", "ExtentsPerSegmentFile");
newFilesPerColumnPartition = sysConfigNew->getConfig("ExtentMap", "FilesPerColumnPartition");
newExtentsPerSegmentFile = sysConfigNew->getConfig("ExtentMap", "ExtentsPerSegmentFile");
if ( oldFilesPerColumnPartition != newFilesPerColumnPartition )
{
try {
sysConfigNew->setConfig("ExtentMap", "FilesPerColumnPartition", oldFilesPerColumnPartition);
}
catch(...)
{
cout << "ERROR: Problem setting FilesPerColumnPartition in the Calpont System Configuration file" << endl;
exit(-1);
}
}
if ( oldExtentsPerSegmentFile != newExtentsPerSegmentFile )
{
try {
sysConfigNew->setConfig("ExtentMap", "ExtentsPerSegmentFile", oldExtentsPerSegmentFile);
}
catch(...)
{
cout << "ERROR: Problem setting ExtentsPerSegmentFile in the Calpont System Configuration file" << endl;
exit(-1);
}
}
}
catch(...)
{
}
//check and update license key
try {
string key = sysConfigOld->getConfig("SystemConfig", "Flags");
if ( !key.empty() )
{
try {
sysConfigNew->setConfig("SystemConfig", "Flags", key);
}
catch(...)
{
cout << "ERROR: Problem setting Flags in the Calpont System Configuration file" << endl;
exit(-1);
}
}
}
catch(...)
{
}
sysConfigNew->write();
if ( extextMapCheckOnly )
exit(0);
systemParentOAMModuleName = "pm1";
//check if systemParentOAMModuleName (pm1) is configured, if not set to 'pm2'
// string IPaddr = sysConfigOld->getConfig("pm1_ProcessMonitor", "IPAddr");
// if ( IPaddr == "0.0.0.0" )
// systemParentOAMModuleName = "pm2";
//set Parent OAM Module Name
try{
sysConfigNew->setConfig(SystemSection, "ParentOAMModuleName", systemParentOAMModuleName);
}
catch(...)
{
cout << "ERROR: Problem updating the Calpont System Configuration file" << endl;
exit(-1);
}
//setup System Name
string oldSystemName;
try {
oldSystemName = sysConfigOld->getConfig(SystemSection, "SystemName");
}
catch(...)
{ }
if ( !oldSystemName.empty() )
systemName = oldSystemName;
try {
sysConfigNew->setConfig(SystemSection, "SystemName", systemName);
}
catch(...)
{
cout << "ERROR: Problem setting SystemName from the Calpont System Configuration file" << endl;
exit(-1);
}
//setup System Language
string systemLang = "C";
try {
systemLang = sysConfigOld->getConfig(SystemSection, "SystemLang");
}
catch(...)
{ }
try {
sysConfigNew->setConfig(SystemSection, "SystemLang", systemLang);
}
catch(...)
{}
//setup HA IP Address
string HA_IPadd;
try {
HA_IPadd = sysConfigOld->getConfig("ProcMgr_HA", "IPAddr");
}
catch(...)
{ }
if ( !HA_IPadd.empty() ) {
try {
sysConfigNew->setConfig("ProcMgr_HA", "IPAddr", HA_IPadd);
}
catch(...)
{
cout << "ERROR: Problem setting ProcMgr_HA from the Calpont System Configuration file" << endl;
exit(-1);
}
}
//setup CMP IP Addresses
string CMP_IPadd;
string CMP_port;
for ( int id = 1 ;; id ++ )
{
string cmpName = "CMP" + oam.itoa(id);
try {
CMP_IPadd = sysConfigOld->getConfig(cmpName, "IPAddr");
}
catch(...)
{ }
if ( !CMP_IPadd.empty() ) {
try {
CMP_port = sysConfigOld->getConfig(cmpName, "Port");
}
catch(...)
{ }
try {
sysConfigNew->setConfig(cmpName, "IPAddr", CMP_IPadd);
sysConfigNew->setConfig(cmpName, "Port", CMP_port);
}
catch(...)
{
cout << "ERROR: Problem setting CMP from the Calpont System Configuration file" << endl;
exit(-1);
}
}
else
break;
}
//setup module and process monitor settings
string ModuleHeartbeatPeriod = "3";
string ModuleHeartbeatCount = "1";
string ProcessRestartCount = "3";
string ProcessRestartPeriod = "1";
string SwapAction = "restartSystem";
string ActivePmFailoverDisabled = "n";
try {
ModuleHeartbeatPeriod = sysConfigOld->getConfig(SystemSection, "ModuleHeartbeatPeriod");
ModuleHeartbeatCount = sysConfigOld->getConfig(SystemSection, "ModuleHeartbeatCount");
ProcessRestartCount = sysConfigOld->getConfig(SystemSection, "ProcessRestartCount");
ProcessRestartPeriod = sysConfigOld->getConfig(SystemSection, "ProcessRestartPeriod");
SwapAction = sysConfigOld->getConfig(SystemSection, "SwapAction");
ActivePmFailoverDisabled = sysConfigOld->getConfig(SystemSection, "ActivePmFailoverDisabled");
}
catch(...)
{ }
try {
sysConfigNew->setConfig(SystemSection, "ModuleHeartbeatPeriod", ModuleHeartbeatPeriod);
sysConfigNew->setConfig(SystemSection, "ModuleHeartbeatCount", ModuleHeartbeatCount);
sysConfigNew->setConfig(SystemSection, "ProcessRestartCount", ProcessRestartCount);
sysConfigNew->setConfig(SystemSection, "ProcessRestartPeriod", ProcessRestartPeriod);
sysConfigNew->setConfig(SystemSection, "SwapAction", SwapAction);
sysConfigNew->setConfig(SystemSection, "ActivePmFailoverDisabled", ActivePmFailoverDisabled);
}
catch(...)
{}
//save EEPackageType and EnableSNMP
string EEPackageType = "rpm";
string EnableSNMP = "y";
try {
EEPackageType = sysConfigOld->getConfig(InstallSection, "EEPackageType");
EnableSNMP = sysConfigOld->getConfig(InstallSection, "EnableSNMP");
}
catch(...)
{ }
try {
sysConfigNew->setConfig(InstallSection, "EEPackageType", EEPackageType);
sysConfigNew->setConfig(InstallSection, "EnableSNMP", EnableSNMP);
}
catch(...)
{ }
if ( EEPackageType.empty() )
EEPackageType = "rpm";
if ( EnableSNMP.empty() )
EnableSNMP = "y";
try {
sysConfigNew->setConfig(InstallSection, "EEPackageType", EEPackageType);
sysConfigNew->setConfig(InstallSection, "EnableSNMP", EnableSNMP);
}
catch(...)
{}
// make DBRM backwards compatiable for pre 1.0.0.157 load
string dbrmMainProc = "DBRM_Controller";
string dbrmSubProc = "DBRM_Worker";
string numSubProc = "NumWorkers";
//set system startup offline option to default 'n'
try {
sysConfigNew->setConfig(InstallSection, "SystemStartupOffline", "n");
}
catch(...)
{
cout << "ERROR: Problem setting systemStartupOffline in the Calpont System Configuration file" << endl;
exit(-1);
}
//CrossEngineSupport
string Host = "";
string Port = "3306";
string User = "";
string Password = "";
try {
Host = sysConfigOld->getConfig("CrossEngineSupport", "Host");
Port = sysConfigOld->getConfig("CrossEngineSupport", "Port");
User = sysConfigOld->getConfig("CrossEngineSupport", "User");
Password = sysConfigOld->getConfig("CrossEngineSupport", "Password");
}
catch(...)
{
Host = "";
Port = "3306";
User = "";
Password = "";
}
try {
sysConfigNew->setConfig("CrossEngineSupport", "Host", Host);
sysConfigNew->setConfig("CrossEngineSupport", "Port", Port);
sysConfigNew->setConfig("CrossEngineSupport", "User", User);
sysConfigNew->setConfig("CrossEngineSupport", "Password", Password);
}
catch(...)
{}
//QueryStats and UserPriority
string QueryStats = "N";
string UserPriority = "N";
try {
QueryStats = sysConfigOld->getConfig("QueryStats", "Enabled");
UserPriority = sysConfigOld->getConfig("UserPriority", "Enabled");
}
catch(...)
{
QueryStats = "N";
UserPriority = "N";
}
try {
sysConfigNew->setConfig("QueryStats", "Enabled", QueryStats);
sysConfigNew->setConfig("UserPriority", "Enabled", UserPriority);
}
catch(...)
{}
// @bug4598, DirectIO setting
string directIO = "y";
try {
directIO = sysConfigOld->getConfig("PrimitiveServers", "DirectIO");
}
catch(...) {
directIO = "y";
}
try {
sysConfigNew->setConfig("PrimitiveServers", "DirectIO", directIO);
}
catch(...)
{}
// @bug4507, configurable pm aggregation AggregationMemoryCheck
string aggMemCheck;
try {
aggMemCheck = sysConfigOld->getConfig("PrimitiveServers", "AggregationMemoryCheck");
if ( !( aggMemCheck.empty() || aggMemCheck == "" ) ) {
sysConfigNew->setConfig("PrimitiveServers", "AggregationMemoryCheck", aggMemCheck);
}
}
catch(...) {
}
//Priority Settings
string HighPriorityPercentage;
try {
HighPriorityPercentage = sysConfigOld->getConfig("PrimitiveServers", "HighPriorityPercentage");
sysConfigNew->setConfig("PrimitiveServers", "HighPriorityPercentage", HighPriorityPercentage);
}
catch(...) {}
string MediumPriorityPercentage;
try {
MediumPriorityPercentage = sysConfigOld->getConfig("PrimitiveServers", "MediumPriorityPercentage");
sysConfigNew->setConfig("PrimitiveServers", "MediumPriorityPercentage", MediumPriorityPercentage);
}
catch(...) {}
string LowPriorityPercentage;
try {
LowPriorityPercentage = sysConfigOld->getConfig("PrimitiveServers", "LowPriorityPercentage");
sysConfigNew->setConfig("PrimitiveServers", "LowPriorityPercentage", LowPriorityPercentage);
}
catch(...) {}
// default to single-server install type
string OserverTypeInstall = oam.itoa(oam::INSTALL_COMBINE_DM_UM_PM);;
string NserverTypeInstall;
string OSingleServerInstall = "y";
int IserverTypeInstall;
try {
OserverTypeInstall = sysConfigOld->getConfig(InstallSection, "ServerTypeInstall");
OSingleServerInstall = sysConfigOld->getConfig(InstallSection, "SingleServerInstall");
}
catch(...)
{
// default to Normal mult-server install type
OserverTypeInstall = oam.itoa(oam::INSTALL_COMBINE_DM_UM_PM);
OSingleServerInstall = "y";
}
// set Server Installation Type
try {
sysConfigNew->setConfig(InstallSection, "ServerTypeInstall", OserverTypeInstall);
sysConfigNew->setConfig(InstallSection, "SingleServerInstall", OSingleServerInstall);
}
catch(...)
{}
NserverTypeInstall = OserverTypeInstall;
IserverTypeInstall = atoi(NserverTypeInstall.c_str());
//set RotatingDestination
switch ( IserverTypeInstall ) {
case (oam::INSTALL_COMBINE_DM_UM_PM): // combined #1 - dm/um/pm on a single server
{
try {
sysConfigNew->setConfig("PrimitiveServers", "RotatingDestination", "n");
}
catch(...)
{
cout << "ERROR: Problem setting RotatingDestination in the Calpont System Configuration file" << endl;
exit(-1);
}
break;
}
}
string parentOAMModuleType = systemParentOAMModuleName.substr(0,MAX_MODULE_TYPE_SIZE);
//
// get Data storage Mount
//
string DBRootStorageType;
int DBRootCount;
string deviceName;
try {
DBRootStorageType = sysConfigOld->getConfig(InstallSection, "DBRootStorageType");
DBRootCount = strtol(sysConfigOld->getConfig(SystemSection, "DBRootCount").c_str(), 0, 0);
}
catch(...)
{
cout << "ERROR: Problem getting DB Storage Data from the Calpont System Configuration file" << endl;
exit(-1);
}
// 2.2 to 3.x+ DBRootStorageTypeconversion
if ( DBRootStorageType == "local" )
DBRootStorageType = "internal";
if ( DBRootStorageType == "storage" )
DBRootStorageType = "external";
try {
sysConfigNew->setConfig(InstallSection, "DBRootStorageType", DBRootStorageType);
}
catch(...)
{
cout << "ERROR: Problem setting DBRootStorageType in the Calpont System Configuration file" << endl;
exit(-1);
}
try {
sysConfigNew->setConfig(SystemSection, "DBRootCount", oam.itoa(DBRootCount));
}
catch(...)
{
cout << "ERROR: Problem setting DBRoot Count in the Calpont System Configuration file" << endl;
exit(-1);
}
//
//Update memory and cache settings
//
string NumBlocksPct;
try {
NumBlocksPct = sysConfigOld->getConfig("DBBC", "NumBlocksPct");
}
catch(...)
{ }
if ( ( NumBlocksPct.empty() || NumBlocksPct == "" ) &&
IserverTypeInstall == oam::INSTALL_COMBINE_DM_UM_PM ) {
NumBlocksPct = "50";
}
if ( !( NumBlocksPct.empty() || NumBlocksPct == "" ) ) {
try {
sysConfigNew->setConfig("DBBC", "NumBlocksPct", NumBlocksPct);
}
catch(...)
{}
}
string TotalUmMemory;
try {
TotalUmMemory = sysConfigOld->getConfig("HashJoin", "TotalUmMemory");
}
catch(...)
{ }
try {
sysConfigNew->setConfig("HashJoin", "TotalUmMemory", TotalUmMemory);
}
catch(...)
{}
string strNumThreads;
try {
strNumThreads = sysConfigOld->getConfig("DBBC", "NumThreads");
}
catch(...)
{ }
if ( !( strNumThreads.empty() || strNumThreads == "" ) ) {
try {
sysConfigNew->setConfig("DBBC", "NumThreads", strNumThreads);
}
catch(...)
{}
}
sysConfigNew->write();
//Get list of configured system modules
SystemModuleTypeConfig sysModuleTypeConfig;
try{
oam.getSystemConfig(sysModuleTypeConfig);
}
catch(...)
{
cout << "ERROR: Problem reading the Calpont System Configuration file" << endl;
exit(-1);
}
//
// Module Configuration
//
string ModuleSection = "SystemModuleConfig";
unsigned int maxPMNicCount = 1;
for ( unsigned int i = 0 ; i < sysModuleTypeConfig.moduletypeconfig.size(); i++)
{
string moduleType = sysModuleTypeConfig.moduletypeconfig[i].ModuleType;
string moduleDesc = sysModuleTypeConfig.moduletypeconfig[i].ModuleDesc;
int moduleCount = sysModuleTypeConfig.moduletypeconfig[i].ModuleCount;
//verify and setup of modules count
switch ( IserverTypeInstall ) {
case (oam::INSTALL_COMBINE_DM_UM_PM):
{
if ( moduleType == "um" ) {
moduleCount = 0;
try {
string ModuleCountParm = "ModuleCount" + oam.itoa(i+1);
sysConfigNew->setConfig(ModuleSection, ModuleCountParm, oam.itoa(moduleCount));
continue;
}
catch(...)
{
cout << "ERROR: Problem setting Module Count in the Calpont System Configuration file" << endl;
exit(-1);
}
}
else
{
try {
string ModuleCountParm = "ModuleCount" + oam.itoa(i+1);
sysConfigNew->setConfig(ModuleSection, ModuleCountParm, oam.itoa(moduleCount));
}
catch(...)
{
cout << "ERROR: Problem setting Module Count in the Calpont System Configuration file" << endl;
exit(-1);
}
}
break;
}
default:
{
try {
string ModuleCountParm = "ModuleCount" + oam.itoa(i+1);
sysConfigNew->setConfig(ModuleSection, ModuleCountParm, oam.itoa(moduleCount));
}
catch(...)
{
cout << "ERROR: Problem setting Module Count in the Calpont System Configuration file" << endl;
exit(-1);
}
break;
}
}
if ( moduleCount == 0 )
//no modules equipped for this Module Type, skip
continue;
if ( moduleType == "pm" )
pmNumber = moduleCount;
//get Module Name IP addresses and Host Names
DeviceNetworkList::iterator listPT = sysModuleTypeConfig.moduletypeconfig[i].ModuleNetworkList.begin();
for( ; listPT != sysModuleTypeConfig.moduletypeconfig[i].ModuleNetworkList.end() ; listPT++)
{
PerformanceModule performancemodule;
string moduleName = (*listPT).DeviceName;
int moduleID = atoi(moduleName.substr(MAX_MODULE_TYPE_SIZE,MAX_MODULE_ID_SIZE).c_str());
string moduleDisableState = (*listPT).DisableState;
if ( moduleDisableState.empty() ||
moduleDisableState == oam::UnassignedName )
moduleDisableState = oam::ENABLEDSTATE;
if ( moduleDisableState == oam::AUTODISABLEDSTATE )
moduleDisableState == oam::ENABLEDSTATE;
//set Module Disable State
string moduleDisableStateParm = "ModuleDisableState" + oam.itoa(moduleID) + "-" + oam.itoa(i+1);
try {
sysConfigNew->setConfig(ModuleSection, moduleDisableStateParm, moduleDisableState);
}
catch(...)
{
cout << "ERROR: Problem setting ModuleDisableState in the Calpont System Configuration file for " + moduleName << endl;
exit(-1);
}
for( unsigned int nicID=1 ; nicID < MAX_NIC+1 ; nicID++ )
{
string moduleIPAddr = oam::UnassignedIpAddr;
string moduleHostName = oam::UnassignedName;
HostConfigList::iterator pt1 = (*listPT).hostConfigList.begin();
for( ; pt1 != (*listPT).hostConfigList.end() ; pt1++)
{
if ( moduleName == (*listPT).DeviceName && (*pt1).NicID == nicID) {
moduleIPAddr = (*pt1).IPAddr;
moduleHostName = (*pt1).HostName;
break;
}
}
if (moduleHostName.empty() || (moduleHostName == oam::UnassignedName) )
// exit out to next module ID
break;
if (moduleIPAddr.empty())
moduleIPAddr = oam::UnassignedIpAddr;
string moduleNameDesc = moduleDesc + " #" + oam.itoa(moduleID);
//set New Module Host Name
string moduleHostNameParm = "ModuleHostName" + oam.itoa(moduleID) + "-" + oam.itoa(nicID) + "-" + oam.itoa(i+1);
try {
sysConfigNew->setConfig(ModuleSection, moduleHostNameParm, moduleHostName);
}
catch(...)
{
cout << "ERROR: Problem setting Host Name in the Calpont System Configuration file" << endl;
exit(-1);
}
//set Module IP address
string moduleIPAddrNameParm = "ModuleIPAddr" + oam.itoa(moduleID) + "-" + oam.itoa(nicID) + "-" + oam.itoa(i+1);
try {
sysConfigNew->setConfig(ModuleSection, moduleIPAddrNameParm, moduleIPAddr);
}
catch(...)
{
cout << "ERROR: Problem setting IP address in the Calpont System Configuration file" << endl;
exit(-1);
}
if ( moduleType == "pm" && moduleDisableState == oam::ENABLEDSTATE ) {
switch(nicID) {
case 1:
performancemodule.moduleIP1 = moduleIPAddr;
break;
case 2:
performancemodule.moduleIP2 = moduleIPAddr;
break;
case 3:
performancemodule.moduleIP3 = moduleIPAddr;
break;
case 4:
performancemodule.moduleIP4 = moduleIPAddr;
break;
}
if ( maxPMNicCount < nicID )
maxPMNicCount = nicID;
}
if ( nicID > 1 )
continue;
//set port addresses
if ( moduleName == systemParentOAMModuleName ) {
parentOAMModuleIPAddr = moduleIPAddr;
//exit out if parentOAMModuleIPAddr is NOT set, this means the System Calpont.xml isn't configured
if ( parentOAMModuleIPAddr == "0.0.0.0" ) {
cout << "ERROR: System Calpont.xml not configured" << endl;
exit(-1);
}
//set Parent Processes Port IP Address
string parentProcessMonitor = systemParentOAMModuleName + "_ProcessMonitor";
sysConfigNew->setConfig(parentProcessMonitor, "IPAddr", parentOAMModuleIPAddr);
sysConfigNew->setConfig(parentProcessMonitor, "Port", "8800");
sysConfigNew->setConfig("ProcMgr", "IPAddr", parentOAMModuleIPAddr);
sysConfigNew->setConfig("ProcStatusControl", "IPAddr", parentOAMModuleIPAddr);
string parentServerMonitor = systemParentOAMModuleName + "_ServerMonitor";
sysConfigNew->setConfig(parentServerMonitor, "IPAddr", parentOAMModuleIPAddr);
sysConfigNew->setConfig(parentServerMonitor, "Port", "8622");
if (build3) {
string portName = systemParentOAMModuleName + "_WriteEngineServer";
sysConfigNew->setConfig(portName, "IPAddr", parentOAMModuleIPAddr);
sysConfigNew->setConfig(portName, "Port", "8630");
}
else
{
sysConfigNew->setConfig("DDLProc", "IPAddr", parentOAMModuleIPAddr);
sysConfigNew->setConfig("DMLProc", "IPAddr", parentOAMModuleIPAddr);
}
if ( IserverTypeInstall == oam::INSTALL_COMBINE_DM_UM_PM ) {
//set User Module's IP Addresses
string Section = "ExeMgr" + oam.itoa(moduleID);
sysConfigNew->setConfig(Section, "IPAddr", moduleIPAddr);
sysConfigNew->setConfig(Section, "Port", "8601");
//set Performance Module's IP's to first NIC IP entered
sysConfigNew->setConfig("DDLProc", "IPAddr", moduleIPAddr);
sysConfigNew->setConfig("DMLProc", "IPAddr", moduleIPAddr);
}
}
else
{
//set child Process Monitor Port IP Address
string portName = moduleName + "_ProcessMonitor";
sysConfigNew->setConfig(portName, "IPAddr", moduleIPAddr);
sysConfigNew->setConfig(portName, "Port", "8800");
//set child Server Monitor Port IP Address
portName = moduleName + "_ServerMonitor";
sysConfigNew->setConfig(portName, "IPAddr", moduleIPAddr);
sysConfigNew->setConfig(portName, "Port", "8622");
//set Performance Module WriteEngineServer Port IP Address
if ( moduleType == "pm" && build3) {
portName = moduleName + "_WriteEngineServer";
sysConfigNew->setConfig(portName, "IPAddr", moduleIPAddr);
sysConfigNew->setConfig(portName, "Port", "8630");
}
//set User Module's IP Addresses
if ( moduleType == "um" ||
( moduleType == "pm" && IserverTypeInstall == oam::INSTALL_COMBINE_DM_UM_PM ) ) {
string Section = "ExeMgr" + oam.itoa(moduleID);
sysConfigNew->setConfig(Section, "IPAddr", moduleIPAddr);
sysConfigNew->setConfig(Section, "Port", "8601");
}
}
//set Performance Module's IP's to first NIC IP entered
if ( moduleName == "um1" && build3) {
sysConfigNew->setConfig("DDLProc", "IPAddr", moduleIPAddr);
sysConfigNew->setConfig("DMLProc", "IPAddr", moduleIPAddr);
}
//setup DBRM processes
if ( moduleName == systemParentOAMModuleName )
sysConfigNew->setConfig(dbrmMainProc, "IPAddr", moduleIPAddr);
if ( moduleDisableState == oam::ENABLEDSTATE ) {
DBRMworkernodeID++;
string DBRMSection = dbrmSubProc + oam.itoa(DBRMworkernodeID);
sysConfigNew->setConfig(DBRMSection, "IPAddr", moduleIPAddr);
sysConfigNew->setConfig(DBRMSection, "Module", moduleName);
}
} //end of nicID loop
//set dbroot assigments
DeviceDBRootList::iterator pt3 = sysModuleTypeConfig.moduletypeconfig[i].ModuleDBRootList.begin();
for( ; pt3 != sysModuleTypeConfig.moduletypeconfig[i].ModuleDBRootList.end() ; pt3++)
{
if ( (*pt3).dbrootConfigList.size() > 0 )
{
int moduleID = (*pt3).DeviceID;
DBRootConfigList::iterator pt4 = (*pt3).dbrootConfigList.begin();
int dbrootCount = (*pt3).dbrootConfigList.size();
string moduleCountParm = "ModuleDBRootCount" + oam.itoa(moduleID) + "-" + oam.itoa(i+1);
try {
sysConfigNew->setConfig(ModuleSection, moduleCountParm, oam.itoa(dbrootCount));
}
catch(...)
{
cout << "ERROR: Problem setting Host Name in the Calpont System Configuration file" << endl;
exit(-1);
}
int entry = 1;
for( ; pt4 != (*pt3).dbrootConfigList.end() ; pt4++, entry++)
{
int dbrootid = *pt4;
string moduleDBRootIDParm = "ModuleDBRootID" + oam.itoa(moduleID) + "-" + oam.itoa(entry) + "-" + oam.itoa(i+1);
try {
sysConfigNew->setConfig(ModuleSection, moduleDBRootIDParm, oam.itoa(dbrootid));
}
catch(...)
{
cout << "ERROR: Problem setting Host Name in the Calpont System Configuration file" << endl;
exit(-1);
}
}
}
}
//assign any unassigned dbroots to pm1 on pre build3 upgrades
if (!build3) {
//get any unassigned DBRoots
DBRootConfigList undbrootlist;
try {
oam.getUnassignedDbroot(undbrootlist);
}
catch(...) {}
if ( !undbrootlist.empty() )
{
string dbrootCount;
int entry = 1;
DBRootConfigList::iterator pt1 = undbrootlist.begin();
for( ; pt1 != undbrootlist.end() ; pt1++ )
{
//skip dbroot #1, already setup
if ( *pt1 == 1 )
continue;
entry++;
string moduleDBRootIDParm = "ModuleDBRootID1-" + oam.itoa(entry) + "-3";
try {
sysConfigNew->setConfig(ModuleSection, moduleDBRootIDParm, oam.itoa(*pt1));
}
catch(...)
{
cout << "ERROR: Problem setting Host Name in the Calpont System Configuration file" << endl;
exit(-1);
}
}
string moduleCountParm = "ModuleDBRootCount1-3";
try {
sysConfigNew->setConfig(ModuleSection, moduleCountParm, oam.itoa(entry));
}
catch(...)
{
cout << "ERROR: Problem setting Host Name in the Calpont System Configuration file" << endl;
exit(-1);
}
}
}
if ( ( moduleType == "pm" && moduleDisableState == oam::ENABLEDSTATE ) ||
( IserverTypeInstall == oam::INSTALL_COMBINE_DM_UM_PM ) )
performancemodulelist.push_back(performancemodule);
} //end of module loop
sysConfigNew->write();
} //end of i for loop
if ( performancemodulelist.size() == 0 )
{
cout << "ERROR: performancemodulelist is empty, exiting..." << endl;
exit(-1);
}
//set dm count to 0 always
try {
sysConfigNew->setConfig(ModuleSection, "ModuleCount1", "0");
}
catch(...)
{
cout << "ERROR: Problem setting Module Count in the Calpont System Configuration file" << endl;
exit(-1);
}
//setup DBRM Controller
sysConfigNew->setConfig(dbrmMainProc, numSubProc, oam.itoa(DBRMworkernodeID));
//setup PrimitiveServers parameters
try {
sysConfigNew->setConfig("PrimitiveServers", "ConnectionsPerPrimProc", oam.itoa(maxPMNicCount*2));
}
catch(...)
{
cout << "ERROR: Problem setting ConnectionsPerPrimProc in the Calpont System Configuration file" << endl;
exit(-1);
}
//set the PM Ports based on Number of PM modules equipped, if any equipped
int minPmPorts = 32;
sysConfigNew->setConfig("PrimitiveServers", "Count", oam.itoa(pmNumber));
int pmPorts = pmNumber * (maxPMNicCount*2);
if ( pmPorts < minPmPorts )
pmPorts = minPmPorts;
if ( pmNumber > 0 ||
( IserverTypeInstall == oam::INSTALL_COMBINE_DM_UM_PM ) )
{
const string PM = "PMS";
for ( int pmsID = 1; pmsID < pmPorts+1 ; )
{
for (unsigned int j = 1 ; j < maxPMNicCount+1 ; j++)
{
PerformanceModuleList::iterator list1 = performancemodulelist.begin();
for (; list1 != performancemodulelist.end() ; list1++)
{
string pmName = PM + oam.itoa(pmsID);
string IpAddr;
switch(j) {
case 1:
IpAddr = (*list1).moduleIP1;
break;
case 2:
IpAddr = (*list1).moduleIP2;
break;
case 3:
IpAddr = (*list1).moduleIP3;
break;
case 4:
IpAddr = (*list1).moduleIP4;
break;
}
if ( !IpAddr.empty() && IpAddr != oam::UnassignedIpAddr ) {
sysConfigNew->setConfig(pmName, "IPAddr", IpAddr);
pmsID++;
if ( pmsID > pmPorts )
break;
}
}
if ( pmsID > pmPorts )
break;
}
}
}
sysConfigNew->write();
//
// Configure Ext Devices
//
SystemExtDeviceConfig systemextdeviceconfig;
try{
oam.getSystemConfig(systemextdeviceconfig);
}
catch(...)
{
cout << "ERROR: Problem reading the Calpont System Configuration file" << endl;
exit(-1);
}
if ( systemextdeviceconfig.Count > 0 ) {
const string NAME = "Name";
const string IPADDR = "IPAddr";
const string DISABLE_STATE = "DisableState";
sysConfigNew->setConfig("SystemExtDeviceConfig", "Count", oam.itoa(systemextdeviceconfig.Count));
for ( unsigned int i = 0 ; i < systemextdeviceconfig.Count ; i++ )
{
string name = NAME + oam.itoa(i+1);
string ipaddr = IPADDR + oam.itoa(i+1);
string disablestate = DISABLE_STATE + oam.itoa(i+1);
sysConfigNew->setConfig("SystemExtDeviceConfig", name, systemextdeviceconfig.extdeviceconfig[i].Name);
sysConfigNew->setConfig("SystemExtDeviceConfig", ipaddr, systemextdeviceconfig.extdeviceconfig[i].IPAddr);
sysConfigNew->setConfig("SystemExtDeviceConfig", disablestate, systemextdeviceconfig.extdeviceconfig[i].DisableState);
}
}
sysConfigNew->write();
//
// Configure NMS Addresses
//
string NMSIPAddress;
try {
NMSIPAddress = sysConfigOld->getConfig(SystemSection, "NMSIPAddress");
}
catch(...)
{
cout << "ERROR: Problem getting NMSIPAddress from Calpont System Configuration file" << endl;
exit(-1);
}
try {
sysConfigNew->setConfig(SystemSection, "NMSIPAddress", NMSIPAddress);
}
catch(...)
{
cout << "ERROR: Problem setting NMSIPAddress in the Calpont System Configuration file" << endl;
exit(-1);
}
//
// setup TransactionArchivePeriod
//
string transactionArchivePeriod;
try {
transactionArchivePeriod = sysConfigOld->getConfig(SystemSection, "TransactionArchivePeriod");
}
catch(...)
{
cout << "ERROR: Problem getting transactionArchivePeriod from Calpont System Configuration file" << endl;
exit(-1);
}
try {
sysConfigNew->setConfig(SystemSection, "TransactionArchivePeriod", transactionArchivePeriod);
}
catch(...)
{
cout << "ERROR: Problem setting IP address in the Calpont System Configuration file" << endl;
exit(-1);
}
//
// 3.0 sn configuration items
//
if (build3) {
//setup cloud parameters
string x509Cert;
string x509PriKey;
string UMStorageType;
string rpw;
string PMInstanceType;
string UMInstanceType;
string UMSecurityGroup;
string UMVolumeSize;
string PMVolumeSize;
string UMAutoSync;
string UMSyncTime;
string AmazonAutoTagging;
string AmazonRegion;
try {
x509Cert = sysConfigOld->getConfig(InstallSection, "AmazonX509Certificate");
x509PriKey = sysConfigOld->getConfig(InstallSection, "AmazonX509PrivateKey");
UMStorageType = sysConfigOld->getConfig(InstallSection, "UMStorageType");
rpw = sysConfigOld->getConfig(InstallSection, "rpw");
PMInstanceType = sysConfigOld->getConfig(InstallSection, "PMInstanceType");
UMInstanceType = sysConfigOld->getConfig(InstallSection, "UMInstanceType");
UMSecurityGroup = sysConfigOld->getConfig(InstallSection, "UMSecurityGroup");
UMVolumeSize = sysConfigOld->getConfig(InstallSection, "UMVolumeSize");
PMVolumeSize = sysConfigOld->getConfig(InstallSection, "PMVolumeSize");
UMAutoSync = sysConfigOld->getConfig(InstallSection, "UMAutoSync");
UMSyncTime = sysConfigOld->getConfig(InstallSection, "UMSyncTime");
AmazonAutoTagging = sysConfigOld->getConfig(InstallSection, "AmazonAutoTagging");
AmazonRegion = sysConfigOld->getConfig(InstallSection, "AmazonRegion");
}
catch(...)
{ }
if ( cloud == "no" )
cloud = "n";
try {
sysConfigNew->setConfig(InstallSection, "Cloud", cloud);
sysConfigNew->setConfig(InstallSection, "AmazonX509Certificate", x509Cert);
sysConfigNew->setConfig(InstallSection, "AmazonX509PrivateKey", x509PriKey);
sysConfigNew->setConfig(InstallSection, "UMStorageType", UMStorageType);
sysConfigNew->setConfig(InstallSection, "rpw", rpw);
sysConfigNew->setConfig(InstallSection, "PMInstanceType", PMInstanceType);
sysConfigNew->setConfig(InstallSection, "UMInstanceType", UMInstanceType);
sysConfigNew->setConfig(InstallSection, "UMSecurityGroup", UMSecurityGroup);
sysConfigNew->setConfig(InstallSection, "UMVolumeSize", UMVolumeSize);
sysConfigNew->setConfig(InstallSection, "PMVolumeSize", PMVolumeSize);
sysConfigNew->setConfig(InstallSection, "UMAutoSync", UMAutoSync);
sysConfigNew->setConfig(InstallSection, "UMSyncTime", UMSyncTime);
sysConfigNew->setConfig(InstallSection, "AmazonAutoTagging", AmazonAutoTagging);
sysConfigNew->setConfig(InstallSection, "AmazonRegion", AmazonRegion);
}
catch(...)
{
// cout << "ERROR: Problem setting Cloud Parameters from the Calpont System Configuration file" << endl;
// exit(-1);
}
//setup um storage
if ( cloud == "amazon" && UMStorageType == "external") {
try
{
systemStorageInfo_t t;
t = oam.getStorageConfig();
ModuleTypeConfig moduletypeconfig;
oam.getSystemConfig("um", moduletypeconfig);
for ( int id = 1; id < moduletypeconfig.ModuleCount+1 ; id++)
{
string volumeNameID = "UMVolumeName" + oam.itoa(id);
string volumeName = oam::UnassignedName;
string deviceNameID = "UMVolumeDeviceName" + oam.itoa(id);
string deviceName = oam::UnassignedName;
try {
volumeName = sysConfigOld->getConfig(InstallSection, volumeNameID);
deviceName = sysConfigOld->getConfig(InstallSection, deviceNameID);
}
catch(...)
{}
try {
sysConfigNew->setConfig(InstallSection, volumeNameID, volumeName);
sysConfigNew->setConfig(InstallSection, deviceNameID, deviceName);
}
catch(...)
{}
}
}
catch (exception& e)
{
cout << endl << "**** getStorageConfig Failed : " << e.what() << endl;
}
}
//setup dbroot storage
try
{
DBRootConfigList dbrootConfigList;
oam.getSystemDbrootConfig(dbrootConfigList);
DBRootConfigList::iterator pt = dbrootConfigList.begin();
for( ; pt != dbrootConfigList.end() ; pt++)
{
int id = *pt;
string DBrootID = "DBRoot" + oam.itoa(id);;
string pathID = "/usr/local/Calpont/data" + oam.itoa(id);
try {
sysConfigNew->setConfig(SystemSection, DBrootID, pathID);
}
catch(...)
{
cout << "ERROR: Problem setting DBRoot in the Calpont System Configuration file" << endl;
exit(-1);
}
if ( cloud == "amazon" && DBRootStorageType == "external") {
string volumeNameID = "PMVolumeName" + oam.itoa(id);
string volumeName = oam::UnassignedName;
string deviceNameID = "PMVolumeDeviceName" + oam.itoa(id);
string deviceName = oam::UnassignedName;
try {
volumeName = sysConfigOld->getConfig(InstallSection, volumeNameID);
deviceName = sysConfigOld->getConfig(InstallSection, deviceNameID);
}
catch(...)
{}
try {
sysConfigNew->setConfig(InstallSection, volumeNameID, volumeName);
sysConfigNew->setConfig(InstallSection, deviceNameID, deviceName);
}
catch(...)
{}
}
}
}
catch (exception& e)
{
cout << endl << "**** getSystemDbrootConfig Failed : " << e.what() << endl;
}
//setup unassigned dbroots
try
{
DBRootConfigList dbrootConfigList;
oam.getUnassignedDbroot(dbrootConfigList);
DBRootConfigList::iterator pt = dbrootConfigList.begin();
for( ; pt != dbrootConfigList.end() ; pt++)
{
int id = *pt;
string DBrootID = "DBRoot" + oam.itoa(id);;
string pathID = "/usr/local/Calpont/data" + oam.itoa(id);
try {
sysConfigNew->setConfig(SystemSection, DBrootID, pathID);
}
catch(...)
{
cout << "ERROR: Problem setting DBRoot in the Calpont System Configuration file" << endl;
exit(-1);
}
if ( cloud == "amazon" && DBRootStorageType == "external") {
string volumeNameID = "VolumeName" + oam.itoa(id);
string volumeName = oam::UnassignedName;
string deviceNameID = "VolumeDeviceName" + oam.itoa(id);
string deviceName = oam::UnassignedName;
try {
volumeName = sysConfigOld->getConfig(InstallSection, volumeNameID);
deviceName = sysConfigOld->getConfig(InstallSection, deviceNameID);
}
catch(...)
{}
try {
sysConfigNew->setConfig(InstallSection, volumeNameID, volumeName);
sysConfigNew->setConfig(InstallSection, deviceNameID, deviceName);
}
catch(...)
{}
}
}
}
catch (exception& e)
{
cout << endl << "**** getUnassignedDbroot Failed : " << e.what() << endl;
}
}
else
{ // pre 3.0 only
string DBRootStorageLoc;
for( int i=1 ; i < DBRootCount+1 ; i++)
{
if ( DBRootStorageType != "local") {
string DBRootStorageLocID = "DBRootStorageLoc" + oam.itoa(i);
try {
DBRootStorageLoc = sysConfigOld->getConfig(InstallSection, DBRootStorageLocID);
}
catch(...)
{
cout << "ERROR: Problem getting '" + DBRootStorageLocID + "' from the Calpont System Configuration file" << endl;
exit(-1);
}
try {
sysConfigNew->setConfig(InstallSection, DBRootStorageLocID, DBRootStorageLoc);
}
catch(...)
{
cout << "ERROR: Problem setting '" + DBRootStorageLocID + "' in the Calpont System Configuration file" << endl;
exit(-1);
}
}
string DBrootID = "DBRoot" + oam.itoa(i);
string pathID = "/usr/local/Calpont/data" + oam.itoa(i);
try {
sysConfigNew->setConfig(SystemSection, DBrootID, pathID);
}
catch(...)
{
cout << "ERROR: Problem setting DBRoot in the Calpont System Configuration file" << endl;
exit(-1);
}
}
}
//do elastic IP configuration
int AmazonElasticIPCount = 0;
try {
AmazonElasticIPCount = atoi(sysConfigOld->getConfig(InstallSection, "AmazonElasticIPCount").c_str());
if (AmazonElasticIPCount > 0 )
{
for ( int id = 1 ; id < AmazonElasticIPCount+1 ; id++ )
{
string AmazonElasticModule = "AmazonElasticModule" + oam.itoa(id);
string ELmoduleName;
string AmazonElasticIPAddr = "AmazonElasticIPAddr" + oam.itoa(id);
string ELIPaddress;
ELmoduleName = sysConfigOld->getConfig(InstallSection, AmazonElasticModule);
ELIPaddress = sysConfigOld->getConfig(InstallSection, AmazonElasticIPAddr);
try {
sysConfigNew->setConfig(InstallSection, "AmazonElasticIPCount", oam.itoa(AmazonElasticIPCount));
sysConfigNew->setConfig(InstallSection, AmazonElasticModule, ELmoduleName);
sysConfigNew->setConfig(InstallSection, AmazonElasticIPAddr, ELIPaddress);
}
catch(...)
{}
}
}
}
catch(...)
{}
try{
oam.getSystemConfig("AmazonElasticIPCount", AmazonElasticIPCount);
}
catch(...) {
AmazonElasticIPCount = 0;
}
// ConcurrentTransactions
string ConcurrentTransactions;
try {
ConcurrentTransactions = sysConfigOld->getConfig(SystemSection, "ConcurrentTransactions");
if ( !ConcurrentTransactions.empty() )
{
try {
sysConfigNew->setConfig(SystemSection, "ConcurrentTransactions", ConcurrentTransactions);
}
catch(...)
{
cout << "ERROR: Problem setting ConcurrentTransactions in the Calpont System Configuration file" << endl;
exit(-1);
}
}
}
catch(...)
{}
// NetworkCompression Enabled
string NetworkCompression;
try {
NetworkCompression = sysConfigOld->getConfig("NetworkCompression", "Enabled");
if ( !NetworkCompression.empty() )
{
try {
sysConfigNew->setConfig("NetworkCompression", "Enabled", NetworkCompression);
}
catch(...)
{
cout << "ERROR: Problem setting NetworkCompression in the Calpont System Configuration file" << endl;
exit(-1);
}
}
}
catch(...)
{}
// CoreFile Flag
string CoreFileFlag;
try {
CoreFileFlag = sysConfigOld->getConfig("Installation", "CoreFileFlag");
if ( !CoreFileFlag.empty() )
{
try {
sysConfigNew->setConfig("Installation", "CoreFileFlag", CoreFileFlag);
}
catch(...)
{
cout << "ERROR: Problem setting CoreFileFlag in the Calpont System Configuration file" << endl;
exit(-1);
}
}
}
catch(...)
{}
//hadoop
string DataFilePlugin;
try {
DataFilePlugin = sysConfigOld->getConfig(SystemSection, "DataFilePlugin");
if ( !DataFilePlugin.empty() )
{
try {
sysConfigNew->setConfig(SystemSection, "DataFilePlugin", DataFilePlugin);
}
catch(...)
{
cout << "ERROR: Problem setting DataFilePlugin in the Calpont System Configuration file" << endl;
exit(-1);
}
string DataFileEnvFile;
try {
DataFileEnvFile = sysConfigOld->getConfig(SystemSection, "DataFileEnvFile");
if ( !DataFileEnvFile.empty() )
{
try {
sysConfigNew->setConfig(SystemSection, "DataFileEnvFile", DataFileEnvFile);
}
catch(...)
{
cout << "ERROR: Problem setting DataFileEnvFile in the Calpont System Configuration file" << endl;
exit(-1);
}
}
else
{
if ( DataFilePlugin == "/usr/local/Calpont/lib/hdfs-20.so" )
DataFileEnvFile = "setenv-hdfs-20";
else
DataFileEnvFile = "setenv-hdfs-12";
try {
sysConfigNew->setConfig(SystemSection, "DataFileEnvFile", DataFileEnvFile);
}
catch(...)
{
cout << "ERROR: Problem setting DataFileEnvFile in the Calpont System Configuration file" << endl;
exit(-1);
}
}
}
catch(...)
{}
string ExtentsPerSegmentFile;
try {
ExtentsPerSegmentFile = sysConfigOld->getConfig("ExtentMap", "ExtentsPerSegmentFile");
try {
sysConfigNew->setConfig("ExtentMap", "ExtentsPerSegmentFile", ExtentsPerSegmentFile);
}
catch(...)
{
cout << "ERROR: Problem setting ExtentsPerSegmentFile in the Calpont System Configuration file" << endl;
exit(-1);
}
}
catch(...)
{}
}
}
catch(...)
{}
string DataFileLog;
try {
DataFileLog = sysConfigOld->getConfig(SystemSection, "DataFileLog");
if ( !DataFileLog.empty() )
{
try {
sysConfigNew->setConfig(SystemSection, "DataFileLog", DataFileLog);
}
catch(...)
{
cout << "ERROR: Problem setting DataFileLog in the Calpont System Configuration file" << endl;
exit(-1);
}
}
}
catch(...)
{}
//Write out Updated System Configuration File
sysConfigNew->write();
}
void test9() {
Oam oamapi;
oamapi.getSystemConfig("ModuleHeartbeatPeriodBad", Ivalue);
CPPUNIT_ASSERT(Ivalue == 0);
};
void test6() {
Oam oamapi;
oamapi.getSystemConfig("SystemVersionBad", Svalue);
CPPUNIT_ASSERT(Svalue.size() == 0);
};
/*****************************************************************************************
* @brief cpuMonitor Thread
*
* purpose: Get current CPU usage, average over 5 readings and report alarms
*
*****************************************************************************************/
void cpuMonitor()
{
ServerMonitor serverMonitor;
// register for Heartbeat monitoring
/* try {
ProcHeartbeat procheartbeat;
procheartbeat.registerHeartbeat(CPU_HEARTBEAT_ID);
}
catch (exception& ex)
{
string error = ex.what();
LoggingID lid(SERVER_MONITOR_LOG_ID);
MessageLog ml(lid);
Message msg;
Message::Args args;
args.add("EXCEPTION ERROR on registerHeartbeat: ");
args.add(error);
msg.format(args);
ml.logErrorMessage(msg);
}
catch(...)
{
LoggingID lid(SERVER_MONITOR_LOG_ID);
MessageLog ml(lid);
Message msg;
Message::Args args;
args.add("EXCEPTION ERROR on sendHeartbeat: Caught unknown exception!");
msg.format(args);
ml.logErrorMessage(msg);
}
*/
int periodCount = 5;
float cpuPeriod[periodCount];
int periodCounter = 0;
float averageCpuUsage = 0;
currentCpuUsage = 0;
// set defaults
unsigned int cpuCritical = 0,
cpuMajor = 0,
cpuMinor = 0,
cpuMinorClear = 0;
// initial cpu Period table
for (int i =0;i < periodCount; i++)
{
cpuPeriod[i] = 0;
}
while(true)
{
// Get CPU usage water mark from server configuration and compare
ModuleTypeConfig moduleTypeConfig;
Oam oam;
try {
oam.getSystemConfig(moduleTypeConfig);
cpuCritical = moduleTypeConfig.ModuleCPUCriticalThreshold;
cpuMajor = moduleTypeConfig.ModuleCPUMajorThreshold;
cpuMinor = moduleTypeConfig.ModuleCPUMinorThreshold;
cpuMinorClear = moduleTypeConfig.ModuleCPUMinorClearThreshold;
} catch (...)
{
sleep(5);
continue;
}
if (RESOURCE_DEBUG)
cout << "critical water: " << moduleTypeConfig.ModuleCPUCriticalThreshold << endl;
pthread_mutex_lock(&CPU_LOCK);
//
// get Process and System CPU usage
//
serverMonitor.getCPUdata();
// store and get average
cpuPeriod[periodCounter] = currentCpuUsage;
averageCpuUsage = 0;
for (int i =0;i < periodCount; i++)
{
averageCpuUsage += cpuPeriod[i];
}
averageCpuUsage = averageCpuUsage / periodCount;
// serverMonitor.logCPUactive(averageCpuUsage);
if (CPU_DEBUG) {
cout << "Current CPU Usage: " << currentCpuUsage << endl;
cout << "Average CPU Usage: " << averageCpuUsage << endl;
}
if (averageCpuUsage >= cpuCritical && cpuCritical > 0 ) {
serverMonitor.sendResourceAlarm("CPU", CPU_USAGE_HIGH, SET, (int) averageCpuUsage);
}
else if (averageCpuUsage >= cpuMajor && cpuMajor > 0 )
serverMonitor.sendResourceAlarm("CPU", CPU_USAGE_MED, SET, (int) averageCpuUsage);
else if (averageCpuUsage >= cpuMinor && cpuMinor > 0 )
serverMonitor.sendResourceAlarm("CPU", CPU_USAGE_LOW, SET, (int) averageCpuUsage);
else if (averageCpuUsage >= cpuMinorClear && cpuMinorClear > 0 ) {
serverMonitor.checkCPUAlarm("CPU", CPU_USAGE_LOW);
//Log this event
LoggingID lid(SERVER_MONITOR_LOG_ID);
MessageLog ml(lid);
Message msg;
Message::Args args;
args.add("Current CPU usage = ");
args.add((int) currentCpuUsage);
args.add(", Average CPU usage = ");
args.add((int) averageCpuUsage);
msg.format(args);
ml.logInfoMessage(msg);
}
else
serverMonitor.checkCPUAlarm("CPU");
//
// check CPU usage by process
//
ProcessCPUList::iterator p = pcl.begin();
while(p != pcl.end())
{
string processName = (*p).processName;
double cpuUsage = (*p).usedPercent;
p++;
if (CPU_DEBUG) {
cout << "Process Name : " << processName << endl;
cout << "CPU Usage: " << cpuUsage << endl;
}
// check if a Calpont Process, if so alarm is over thresholds
// if not, just log if over thresholds
if (cpuUsage >= cpuCritical && cpuCritical > 0) {
/* try {
t = oam.getMyProcessStatus(processID);
processName = boost::get<1>(t);
serverMonitor.sendResourceAlarm(processName, CPU_USAGE_HIGH, SET, (int) cpuUsage);
}
catch (...) {
*/ LoggingID lid(SERVER_MONITOR_LOG_ID);
MessageLog ml(lid);
Message msg;
Message::Args args;
args.add("Process");
args.add(processName);
args.add(" above Critical CPU threshold with a percentage of ");
args.add((int) cpuUsage);
msg.format(args);
ml.logInfoMessage(msg);
// }
}
else if (cpuUsage >= cpuMajor && cpuMajor > 0) {
/* try {
t = oam.getMyProcessStatus(processID);
processName = boost::get<1>(t);
serverMonitor.sendResourceAlarm(processName, CPU_USAGE_MED, SET, (int) cpuUsage);
}
catch (...) {
*/ LoggingID lid(SERVER_MONITOR_LOG_ID);
MessageLog ml(lid);
Message msg;
Message::Args args;
args.add("Process");
args.add(processName);
args.add(" above Major CPU threshold with a percentage of ");
args.add((int) cpuUsage);
msg.format(args);
ml.logInfoMessage(msg);
// }
}
else if (cpuUsage >= cpuMinor && cpuMinor > 0) {
/* try {
t = oam.getMyProcessStatus(processID);
processName = boost::get<1>(t);
serverMonitor.sendResourceAlarm(processName, CPU_USAGE_LOW, SET, (int) cpuUsage);
}
catch (...) {
*/ LoggingID lid(SERVER_MONITOR_LOG_ID);
MessageLog ml(lid);
Message msg;
Message::Args args;
args.add("Process");
args.add(processName);
args.add(" above Minor CPU threshold with a percentage of ");
args.add((int) cpuUsage);
msg.format(args);
ml.logInfoMessage(msg);
// }
}
/* else if (cpuUsage >= cpuMinorClear) {
try {
t = oam.getMyProcessStatus(processID);
processName = boost::get<1>(t);
serverMonitor.checkCPUAlarm(processName, CPU_USAGE_LOW);
}
catch (...) {}
}
else
serverMonitor.checkCPUAlarm(processName);
*/ }
// send heartbeat message
/* try {
ProcHeartbeat procheartbeat;
procheartbeat.sendHeartbeat(CPU_HEARTBEAT_ID);
LoggingID lid(SERVER_MONITOR_LOG_ID);
MessageLog ml(lid);
Message msg;
Message::Args args;
args.add("Sent Heartbeat Msg");
msg.format(args);
ml.logInfoMessage(msg);
}
catch (exception& ex)
{
string error = ex.what();
if ( error.find("Disabled") == string::npos ) {
LoggingID lid(SERVER_MONITOR_LOG_ID);
MessageLog ml(lid);
Message msg;
Message::Args args;
args.add("EXCEPTION ERROR on sendHeartbeat: ");
args.add(error);
msg.format(args);
ml.logErrorMessage(msg);
}
}
catch(...)
{
LoggingID lid(SERVER_MONITOR_LOG_ID);
MessageLog ml(lid);
Message msg;
Message::Args args;
args.add("EXCEPTION ERROR on sendHeartbeat: Caught unknown exception!");
msg.format(args);
ml.logErrorMessage(msg);
}
*/
pthread_mutex_unlock(&CPU_LOCK);
// sleep, 5 minutes
sleep(MONITOR_PERIOD*5);
++periodCounter;
if ( periodCounter >= periodCount )
periodCounter = 0;
} // end of while loop
}
/******************************************************************************************
* @brief sendUpgradeRequest
*
* purpose: send Upgrade Request Msg to all ACTIVE UMs
*
*
******************************************************************************************/
int sendUpgradeRequest(int IserverTypeInstall)
{
Oam oam;
while(true)
{
try{
ProcessStatus procstat;
oam.getProcessStatus("WriteEngineServer", "pm1", procstat);
if ( procstat.ProcessOpState == oam::ACTIVE)
break;
}
catch (exception& ex)
{}
}
SystemModuleTypeConfig systemmoduletypeconfig;
try{
oam.getSystemConfig(systemmoduletypeconfig);
}
catch (exception& ex)
{}
ByteStream msg;
ByteStream::byte requestID = RUNUPGRADE;
msg << requestID;
msg << mysqlpw;
int returnStatus = oam::API_SUCCESS;
for( unsigned int i = 0; i < systemmoduletypeconfig.moduletypeconfig.size(); i++)
{
int moduleCount = systemmoduletypeconfig.moduletypeconfig[i].ModuleCount;
if( moduleCount == 0)
continue;
string moduleType = systemmoduletypeconfig.moduletypeconfig[i].ModuleType;
if ( moduleType == "um" ||
( moduleType == "pm" && IserverTypeInstall == oam::INSTALL_COMBINE_DM_UM_PM ) ) {
DeviceNetworkList::iterator pt = systemmoduletypeconfig.moduletypeconfig[i].ModuleNetworkList.begin();
for ( ; pt != systemmoduletypeconfig.moduletypeconfig[i].ModuleNetworkList.end(); pt++)
{
int opState;
bool degraded;
try {
oam.getModuleStatus((*pt).DeviceName, opState, degraded);
if (opState == oam::ACTIVE) {
returnStatus = sendMsgProcMon( (*pt).DeviceName, msg, requestID, 30 );
if ( returnStatus != API_SUCCESS)
return returnStatus;
}
}
catch (exception& ex)
{}
}
}
}
return returnStatus;
}
int main(int argc, char *argv[])
{
Oam oam;
string installDir(startup::StartUp::installDir());
Config* sysConfig = Config::makeConfig();
string SystemSection = "SystemConfig";
string InstallSection = "Installation";
bool HARDWARE = false;
bool SOFTWARE = false;
bool CONFIG = false;
bool DBMS = false;
bool RESOURCE = false;
bool LOG = false;
bool BULKLOG = false;
bool HADOOP = false;
//get current time and date
time_t now;
now = time(NULL);
struct tm tm;
localtime_r(&now, &tm);
char timestamp[200];
strftime (timestamp, 200, "%m:%d:%y-%H:%M:%S", &tm);
currentDate = timestamp;
char helpArg[3] = "-h";
// Get System Name
try{
oam.getSystemConfig("SystemName", systemName);
}
catch(...)
{
systemName = "unassigned";
}
// get Local Module Name and Server Install Indicator
string singleServerInstall;
oamModuleInfo_t st;
try {
st = oam.getModuleInfo();
localModule = boost::get<0>(st);
}
catch (...) {
cout << endl << "**** Failed : Failed to read Local Module Name" << endl;
exit(-1);
}
try{
oam.getSystemConfig("SingleServerInstall", singleServerInstall);
}
catch(...)
{
singleServerInstall = "y";
}
if (argc == 1) {
argv[1] = &helpArg[0];
argc = 2;
}
string DataFilePlugin;
try{
DataFilePlugin = sysConfig->getConfig(SystemSection, "DataFilePlugin");
}
catch(...)
{
cout << "ERROR: Problem accessing InfiniDB configuration file" << endl;
exit(-1);
}
for( int i = 1; i < argc; i++ )
{
if( string("-h") == argv[i] ) {
cout << endl;
cout << "'calpontSupport' generates a Set of System Support Report Files in a tar file" << endl;
cout << "called calpontSupportReport.'system-name'.tar.gz in the local directory." << endl;
cout << "It should be run on the server with the DBRM front-end." << endl;
cout << "Check the Admin Guide for additional information." << endl;
cout << endl;
cout << "Usage: calpontSupport [-h][-a][-hw][-s][-c][-db][-r][-l][-bl][-lc][-p 'root-password'][-mp 'mysql-root-password'][-de]";
// if hdfs set up print the hadoop option
if (!DataFilePlugin.empty())
cout << "[-hd]";
cout << endl;
cout << " -h help" << endl;
cout << " -a Output all Reports (excluding Bulk Logs Reports)" << endl;
cout << " -hw Output Hardware Reports only" << endl;
cout << " -s Output Software Reports only" << endl;
cout << " -c Output Configuration/Status Reports only" << endl;
cout << " -db Output DBMS Reports only" << endl;
cout << " -r Output Resource Reports only" << endl;
cout << " -l Output Calpont Log/Alarms Reports only" << endl;
cout << " -bl Output Calpont Bulk Log Reports only" << endl;
cout << " -lc Output Reports for Local Server only" << endl;
cout << " -p password (multi-server systems), root-password or 'ssh' to use 'ssh keys'" << endl;
cout << " -mp mysql root user password" << endl;
cout << " -de Debug Flag" << endl;
// if hdfs set up print the hadoop option
if (!DataFilePlugin.empty())
cout << " -hd Output hadoop reports only" << endl;
exit (0);
}
else
{
if( string("-a") == argv[i] ) {
HARDWARE = true;
SOFTWARE = true;
CONFIG = true;
DBMS = true;
RESOURCE = true;
LOG = true;
HADOOP = (DataFilePlugin.empty()? false : true);
}
else if( string("-hw") == argv[i] )
HARDWARE = true;
else if( string("-s") == argv[i] )
SOFTWARE = true;
else if( string("-c") == argv[i] )
CONFIG = true;
else if( string("-db") == argv[i] )
DBMS = true;
else if( string("-r") == argv[i] )
RESOURCE = true;
else if( string("-l") == argv[i] )
LOG = true;
else if( string("-bl") == argv[i] )
BULKLOG = true;
else if( string("-lc") == argv[i] )
LOCAL = true;
else if( string("-p") == argv[i] ) {
i++;
if ( argc == i ) {
cout << "ERROR: missing root password argument" << endl;
exit(-1);
}
rootPassword = argv[i];
//add single quote for special characters
if ( rootPassword != "ssh" )
{
rootPassword = "******" + rootPassword + "'";
}
}
else if( string("-mp") == argv[i] ) {
i++;
if ( argc == i ) {
cout << "ERROR: missing mysql root user password argument" << endl;
exit(-1);
}
mysqlpw = argv[i];
mysqlpw = "'" + mysqlpw + "'";
}
else if( string("-de") == argv[i] )
debug_flag = "1";
else if ( string("-hd") == argv[i] )
{
HADOOP = (DataFilePlugin.empty()? false : true);
}
else
{
cout << "Invalid Option of '" << argv[i] << "', run with '-h' for help" << endl;
exit (1);
}
}
}
//default to -a if nothing is set
if ( !HARDWARE && !SOFTWARE && !CONFIG && !DBMS && !RESOURCE && !LOG && !BULKLOG && !HADOOP)
{
HARDWARE = true;
SOFTWARE = true;
CONFIG = true;
DBMS = true;
RESOURCE = true;
LOG = true;
HADOOP = (DataFilePlugin.empty()? false : true);
}
//get Parent OAM Module Name and setup of it's Custom OS files
string PrimaryUMModuleName;
try{
PrimaryUMModuleName = sysConfig->getConfig(SystemSection, "PrimaryUMModuleName");
}
catch(...)
{
cout << "ERROR: Problem getting Parent OAM Module Name" << endl;
exit(-1);
}
if ( PrimaryUMModuleName == "unassigned" )
PrimaryUMModuleName = localModule;
if ( (localModule != PrimaryUMModuleName) && DBMS )
{
char* pcommand = 0;
char *p;
string argument = "n";
while(true)
{
cout << endl << "You selected to get the DBMS data." << endl;
cout << "You need to run the calpontSupport command on module '" << PrimaryUMModuleName << "' to get that information." << endl;
cout << "Or you can proceed on to get all data except the DBMS." << endl;
pcommand = readline(" Do you want to proceed: (y or n) [n]: ");
if (pcommand && *pcommand) {
p = strtok(pcommand," ");
argument = p;
free(pcommand);
pcommand = 0;
}
if (pcommand) {
free(pcommand);
pcommand = 0;
}
if( argument == "y") {
cout << endl;
break;
}
else if( argument == "n")
exit (1);
}
}
//get number of worker-nodes, will tell us if a single server system
//get Parent OAM Module Name and setup of it's Custom OS files
try{
string NumWorkers = sysConfig->getConfig("DBRM_Controller", "NumWorkers");
if ( NumWorkers == "1" )
singleServerInstall = "y";
}
catch(...)
{}
if ( singleServerInstall == "n" && !LOCAL)
if ( HARDWARE || SOFTWARE || CONFIG || RESOURCE || LOG || HADOOP )
if ( rootPassword.empty() ) {
cout << "ERROR: Multi-Module System, Password Argument required or use '-lc' option, check help for more information" << endl;
exit(-1);
}
//get Parent OAM Module Name and setup of it's Custom OS files
//string parentOAMModuleName;
ChildModule parentOAMModule;
try{
parentOAMModule.moduleName = sysConfig->getConfig(SystemSection, "ParentOAMModuleName");
}
catch(...)
{
cout << "ERROR: Problem getting Parent OAM Module Name" << endl;
exit(-1);
}
//Get list of configured system modules
SystemModuleTypeConfig sysModuleTypeConfig;
try{
oam.getSystemConfig(sysModuleTypeConfig);
}
catch(...)
{
cout << "ERROR: Problem reading the Calpont System Configuration file" << endl;
exit(-1);
}
string ModuleSection = "SystemModuleConfig";
for ( unsigned int i = 0 ; i < sysModuleTypeConfig.moduletypeconfig.size(); i++)
{
string moduleType = sysModuleTypeConfig.moduletypeconfig[i].ModuleType;
int moduleCount = sysModuleTypeConfig.moduletypeconfig[i].ModuleCount;
if ( moduleCount == 0 )
//no modules equipped for this Module Type, skip
continue;
//get IP addresses and Host Names
DeviceNetworkList::iterator listPT = sysModuleTypeConfig.moduletypeconfig[i].ModuleNetworkList.begin();
for( ; listPT != sysModuleTypeConfig.moduletypeconfig[i].ModuleNetworkList.end() ; listPT++)
{
string moduleName = (*listPT).DeviceName;
HostConfigList::iterator pt1 = (*listPT).hostConfigList.begin();
string moduleIPAddr = (*pt1).IPAddr;
string moduleHostName = (*pt1).HostName;
if ( moduleName == localModule) {
localModuleHostName = moduleHostName;
}
//save Child modules
if ( moduleName != localModule && moduleType != "xm") {
childmodule.moduleName = moduleName;
childmodule.moduleIP = moduleIPAddr;
childmodule.hostName = moduleHostName;
childmodulelist.push_back(childmodule);
}
if (moduleName == parentOAMModule.moduleName)
{
parentOAMModule.moduleIP = moduleIPAddr;
parentOAMModule.hostName = moduleHostName;
parentOAMModule.moduleName = moduleName;
}
}
} //end of i for loop
// create a clean Calpont Support Report
system("rm -f *_configReport.txt");
system("rm -f *_dbmsReport.txt");
system("rm -f *_hardwareReport.txt");
system("rm -f *_logReport.txt");
system("rm -f *_bulklogReport.txt");
system("rm -f *_resourceReport.txt");
system("rm -f *_softwareReport.txt");
system("rm -f hadoopReport.txt");
//
// Software
//
if ( SOFTWARE ) {
string reportType = "software";
pthread_t reportthread;
int status = pthread_create (&reportthread, NULL, (void*(*)(void*)) &reportThread, &reportType);
if ( status != 0 ) {
cout << "ERROR: reportthread: pthread_create failed, return status = " + oam.itoa(status);
}
sleep(5);
}
//
// Configuration
//
if ( CONFIG ) {
string reportType = "config";
pthread_t reportthread;
int status = pthread_create (&reportthread, NULL, (void*(*)(void*)) &reportThread, &reportType);
if ( status != 0 ) {
cout << "ERROR: reportthread: pthread_create failed, return status = " + oam.itoa(status);
}
sleep(5);
}
//
// Alarms and Calpont Logs
//
if ( LOG ) {
string reportType = "log";
pthread_t reportthread;
int status = pthread_create (&reportthread, NULL, (void*(*)(void*)) &reportThread, &reportType);
if ( status != 0 ) {
cout << "ERROR: reportthread: pthread_create failed, return status = " + oam.itoa(status);
}
sleep(5);
}
//
// Bulk Logs
//
if ( BULKLOG ) {
string reportType = "bulklog";
pthread_t reportthread;
int status = pthread_create (&reportthread, NULL, (void*(*)(void*)) &reportThread, &reportType);
if ( status != 0 ) {
cout << "ERROR: reportthread: pthread_create failed, return status = " + oam.itoa(status);
}
sleep(5);
}
//
// Hardware
//
if ( HARDWARE ) {
string reportType = "hardware";
pthread_t reportthread;
int status = pthread_create (&reportthread, NULL, (void*(*)(void*)) &reportThread, &reportType);
if ( status != 0 ) {
cout << "ERROR: reportthread: pthread_create failed, return status = " + oam.itoa(status);
}
sleep(5);
}
//
// Resources
//
if ( RESOURCE ) {
string reportType = "resource";
pthread_t reportthread;
int status = pthread_create (&reportthread, NULL, (void*(*)(void*)) &reportThread, &reportType);
if ( status != 0 ) {
cout << "ERROR: reportthread: pthread_create failed, return status = " + oam.itoa(status);
}
sleep(5);
}
//
// DBMS
//
if ( DBMS ) {
system("rm -f calpontSupportReport.txt;touch calpontSupportReport.txt");
title();
system("echo '=======================================================================' >> calpontSupportReport.txt");
system("echo '= DBMS Report =' >> calpontSupportReport.txt");
system("echo '=======================================================================' >> calpontSupportReport.txt");
// run DBMS report on local server
cout << "Get dbms report data for " << localModule << endl;
bool FAILED = false;
if ( localModule != PrimaryUMModuleName )
{
cout << " FAILED: run calpontSupport on '" << PrimaryUMModuleName << "' to get the dbrm report" << endl;
FAILED = true;
}
else
{
// check if mysql is supported and get info
string calpontMysql = installDir + "/mysql/bin/mysql --defaults-file=" + installDir + "/mysql/my.cnf -u root ";
string cmd = calpontMysql + " -e 'status' > /tmp/idbmysql.log 2>&1";
system(cmd.c_str());
//check for mysql password set
string pwprompt = " ";
if (oam.checkLogStatus("/tmp/idbmysql.log", "ERROR 1045") ) {
cout << "NOTE: MySQL root user password is set" << endl;
//needs a password, was password entered on command line
if ( mysqlpw == " " )
{ //go check my.cnf
string file = installDir + "/mysql/my.cnf";
ifstream oldFile (file.c_str());
vector <string> lines;
char line[200];
string buf;
while (oldFile.getline(line, 200))
{
buf = line;
string::size_type pos = buf.find("password",0);
if (pos != string::npos) {
string::size_type pos1 = buf.find("=",0);
if (pos1 != string::npos) {
pos = buf.find("#",0);
if (pos == string::npos) {
//password arg in my.cnf, go get password
cout << "NOTE: Using password from my.cnf" << endl;
mysqlpw = buf.substr(pos1+1,80);
cout << mysqlpw << endl;
break;
}
}
}
}
oldFile.close();
if ( mysqlpw == " " )
{
cout << "NOTE: No password provide on command line or found uncommented in my.cnf" << endl;
cout << endl;
string prompt = " *** Enter MySQL password > ";
mysqlpw = getpass(prompt.c_str());
}
}
//check for mysql password set
pwprompt = "--password="******" -e 'status' > /tmp/idbmysql.log 2>&1";
system(cmd.c_str());
if (oam.checkLogStatus("/tmp/idbmysql.log", "ERROR 1045") ) {
cout << "FAILED: Failed login using MySQL root user password '" << mysqlpw << "'" << endl;
FAILED = true;
}
}
if (!FAILED)
{
// check if mysql is supported and get info
string calpontMysql = installDir + "/mysql/bin/mysql --defaults-file=" + installDir + "/mysql/my.cnf -u root " + pwprompt;
string cmd = calpontMysql + " -V > /dev/null 2>&1";
int ret = system(cmd.c_str());
if ( WEXITSTATUS(ret) == 0) {
// run DBMS report info
system("echo ' ' >> calpontSupportReport.txt");
system("echo '******************** DBMS InfiniDB Mysql Version ********************' >> calpontSupportReport.txt");
system("echo ' ' >> calpontSupportReport.txt");
cmd = "echo '################# " + calpontMysql + " -e status ################# ' >> calpontSupportReport.txt";
system(cmd.c_str());
cmd = "echo ' ' >> calpontSupportReport.txt";
system(cmd.c_str());
cmd = calpontMysql + " -e 'status' >> calpontSupportReport.txt";
system(cmd.c_str());
system("echo ' ' >> calpontSupportReport.txt");
system("echo '******************** DBMS Mysql Calpont System Column ********************' >> calpontSupportReport.txt");
system("echo ' ' >> calpontSupportReport.txt");
cmd = "echo '################# " + calpontMysql + " -e desc calpontsys.syscolumn ################# ' >> calpontSupportReport.txt";
system(cmd.c_str());
cmd = "echo ' ' >> calpontSupportReport.txt";
system(cmd.c_str());
cmd = calpontMysql + " -e 'desc calpontsys.syscolumn;' >> calpontSupportReport.txt";
system(cmd.c_str());
system("echo ' ' >> calpontSupportReport.txt");
system("echo '******************** DBMS Mysql Calpont System Table ********************' >> calpontSupportReport.txt");
system("echo ' ' >> calpontSupportReport.txt");
cmd = "echo '################# " + calpontMysql + " -e desc calpontsys.systable ################# ' >> calpontSupportReport.txt";
system(cmd.c_str());
cmd = "echo ' ' >> calpontSupportReport.txt";
system(cmd.c_str());
cmd = calpontMysql + " -e 'desc calpontsys.systable;' >> calpontSupportReport.txt";
system(cmd.c_str());
system("echo ' ' >> calpontSupportReport.txt");
system("echo '******************** DBMS Mysql Calpont System Catalog Data ********************' >> calpontSupportReport.txt");
system("echo ' ' >> calpontSupportReport.txt");
cmd = "echo '################# " + calpontMysql + " calpontsys < " + installDir + "/mysql/dumpcat_mysql.sql ################# ' >> calpontSupportReport.txt";
system(cmd.c_str());
cmd = "echo ' ' >> calpontSupportReport.txt";
system(cmd.c_str());
cmd = calpontMysql + " calpontsys < " + installDir + "/mysql/dumpcat_mysql.sql >> calpontSupportReport.txt";
system(cmd.c_str());
system("echo ' ' >> calpontSupportReport.txt");
system("echo '******************** DBMS Mysql Calpont System Table Data ********************' >> calpontSupportReport.txt");
system("echo ' ' >> calpontSupportReport.txt");
cmd = "echo '################# " + calpontMysql + " -e select * from calpontsys.systable ################# ' >> calpontSupportReport.txt";
system(cmd.c_str());
cmd = "echo ' ' >> calpontSupportReport.txt";
system(cmd.c_str());
cmd = calpontMysql + " -e 'select * from calpontsys.systable;' >> calpontSupportReport.txt";
system(cmd.c_str());
system("echo ' ' >> calpontSupportReport.txt");
system("echo '******************** DBMS Mysql Calpont Usernames ********************' >> calpontSupportReport.txt");
system("echo ' ' >> calpontSupportReport.txt");
cmd = "echo '################# " + calpontMysql + " -e show databases ################# ' >> calpontSupportReport.txt";
system(cmd.c_str());
cmd = "echo ' ' >> calpontSupportReport.txt";
system(cmd.c_str());
cmd = calpontMysql + " -e 'show databases;' >> calpontSupportReport.txt";
system(cmd.c_str());
system("echo ' ' >> calpontSupportReport.txt");
system("echo '******************** DBMS Mysql InfiniDB variables ********************' >> calpontSupportReport.txt");
system("echo ' ' >> calpontSupportReport.txt");
cmd = "echo '################# " + calpontMysql + " show variables ################# ' >> calpontSupportReport.txt";
system(cmd.c_str());
cmd = "echo ' ' >> calpontSupportReport.txt";
system(cmd.c_str());
cmd = calpontMysql + " -e 'show variables;' >> calpontSupportReport.txt";
system(cmd.c_str());
}
}
}
system("echo ' ' >> calpontSupportReport.txt");
system("echo '******************** Database Size Report ********************' >> calpontSupportReport.txt");
system("echo ' ' >> calpontSupportReport.txt");
string cmd = "echo '################# /bin/databaseSizeReport ################# ' >> calpontSupportReport.txt";
system(cmd.c_str());
cmd = "echo ' ' >> calpontSupportReport.txt";
system(cmd.c_str());
cmd = installDir + "/bin/databaseSizeReport >> calpontSupportReport.txt";
system(cmd.c_str());
system("echo ' ' >> calpontSupportReport.txt");
system("echo '******************** DBMS Mysql InfiniDB config file ********************' >> calpontSupportReport.txt");
system("echo ' ' >> calpontSupportReport.txt");
cmd = "echo '################# cat /mysql/my.cnf ################# ' >> calpontSupportReport.txt";
system(cmd.c_str());
cmd = "echo ' ' >> calpontSupportReport.txt";
system(cmd.c_str());
cmd = "cat " + installDir + "/mysql/my.cnf 2>/dev/null >> calpontSupportReport.txt";
system(cmd.c_str());
system("echo ' ' >> calpontSupportReport.txt");
system("echo '******************** Active Queries ********************' >> calpontSupportReport.txt");
system("echo ' ' >> calpontSupportReport.txt");
cmd = "echo '################# mcsadmin getActiveSqlStatement ################# ' >> calpontSupportReport.txt";
system(cmd.c_str());
cmd = "echo ' ' >> calpontSupportReport.txt";
system(cmd.c_str());
cmd = installDir + "/bin/mcsadmin getActiveSqlStatement >> calpontSupportReport.txt";
system(cmd.c_str());
cmd = "cat calpontSupportReport.txt > " + localModule + "_dbmsReport.txt";
system(cmd.c_str());
}
//
// HADOOP
//
if (HADOOP)
{
if (LOCAL || childmodulelist.empty())
{
cout << "Get hadoop report data" << endl;
string cmd = installDir + "/bin/hadoopReport.sh " + localModule + " " + installDir + "\n";
cmd += " mv -f /tmp/hadoopReport.txt .";
FILE* pipe = popen(cmd.c_str(), "r");
if (!pipe)
{
cout << "Failed to get a pipe for hadoop health check commands" << endl;
exit(-1);
}
pclose(pipe);
}
else
{
// only get hadoop report from parentOAMModule, because it's consistant view.
parentmodulelist.push_back(parentOAMModule);
threadInfo_t *st = new threadInfo_t;
ChildModuleList::iterator iter = parentmodulelist.begin();
*st = boost::make_tuple(iter, "hadoop");
pthread_t hdthread;
int status = pthread_create (&hdthread, NULL, (void*(*)(void*)) &childReportThread, st);
if ( status != 0 )
{
cout << "ERROR: childreportthread: pthread_create failed, return status = " + oam.itoa(status) << endl;
}
}
}
//wait for all threads to complete
sleep(5);
int wait = 0;
while (true)
{
//cout << "check " << runningThreads << endl;
if (runningThreads < 1)
break;
sleep(2);
wait++;
// give it 60 minutes to complete
if ( wait >= 3600 * 5)
{
cout << "Timed out (60 minutes) waiting for Requests to complete" << endl;
}
}
system("rm -f calpontSupportReport.txt");
system("unix2dos *Report.txt > /dev/null 2>&1");
system("rm -rf calpontSupportReport;mkdir calpontSupportReport;mv *Report.txt calpontSupportReport/. > /dev/null 2>&1;mv *Report.tar.gz calpontSupportReport/. > /dev/null 2>&1");
string cmd = "tar -zcf calpontSupportReport." + systemName + ".tar.gz calpontSupportReport/*";
system(cmd.c_str());
cout << endl << "Calpont Support Script Successfully completed, files located in calpontSupportReport." + systemName + ".tar.gz" << endl;
}
//------------------------------------------------------------------------------
// Loads the UM module information from the Calpont.xml file, so that we have
// the list of IP addresses that are valid for each UM. Note that this method
// does not insure thread safeness, but that's okay because it is assumed that
// it will only be called once from the first call to instance().
//------------------------------------------------------------------------------
void
UmSocketSelector::loadUMModuleInfo()
{
Oam oam;
ModuleTypeConfig moduleTypeConfig;
const std::string UM_MODTYPE("um");
oam.getSystemConfig(UM_MODTYPE, moduleTypeConfig);
int moduleCount= moduleTypeConfig.ModuleCount;
std::string moduleType = moduleTypeConfig.ModuleType;
#ifdef LOAD_MODULE_DEBUG
std::cout << "ModuleConfig for type: " << UM_MODTYPE << std::endl;
std::cout << "ModuleDesc = " << moduleTypeConfig.ModuleDesc << std::endl;
std::cout << "ModuleCount = " << moduleCount << std::endl;
std::cout << "RunType = " << moduleTypeConfig.RunType << std::endl;
#endif
if ( moduleCount > 0 )
{
//..Loop through the list of UM modules
for (DeviceNetworkList::iterator iter1 =
moduleTypeConfig.ModuleNetworkList.begin();
(iter1 != moduleTypeConfig.ModuleNetworkList.end());
++iter1)
{
std::string moduleName = iter1->DeviceName;
#ifdef LOAD_MODULE_DEBUG
std::cout << "ModuleName-" << moduleName << std::endl;
#endif
//..Assign the UM index based on whether it is a new UM or one
// we have seen before
unsigned int umIdx = findOrAddUm( moduleName );
//..Get the list of IP addresses (NIC's) for this UM module
for (HostConfigList::iterator iter2 = iter1->hostConfigList.begin();
(iter2 != iter1->hostConfigList.end());
++iter2)
{
std::string ipAddr = iter2->IPAddr;
#ifdef LOAD_MODULE_DEBUG
std::cout << " NIC-" << iter2->NicID <<
"; host-" << iter2->HostName <<
"; IP-" << ipAddr << std::endl;
#endif
struct in_addr ip;
if ( inet_aton(ipAddr.c_str(), &ip ) )
{
fIpAddressUmMap[ ip.s_addr ] = umIdx;
fUmModuleIPs[umIdx]->addIP( ip.s_addr );
}
else
{
std::cerr << "Invalid IP address in SystemModuleConfig "
"section: " << ipAddr << std::endl;
}
} // loop through the IP addresses for a UM module
} // loop through the list of UM modules
} // moduleCount > 0
}
/*****************************************************************************************
* @brief main function
*
* purpose: Get current CPU usage and return current state
*
*****************************************************************************************/
int main (int argc, char** argv)
{
unsigned int *times;
unsigned int cpuUsage = 0;
// set defaults
unsigned int cpuCritical = 9000,
cpuMajor = 8000,
cpuMinor = 7000,
cpuMinorClear = 6000;
strcpy (cpu, "cpu");
// get specific CPU info
times = diffUsage();
// no cpus available on the system
if (times == NULL)
{
cout << "No cpus on the system" << endl;
return 0;
}
cpuUsage = calcCPUusage(times);
logCPUactive(cpuUsage);
cout << "cpuUsage: " << cpuUsage << endl;
// Get CPU usage water mark from server configuration and compare
ServerConfig serverConfig;
Oam oam;
try {
oam.getSystemConfig (serverConfig);
cpuCritical = serverConfig.ServerCPUCriticalThreshold;
cpuMajor = serverConfig.ServerCPUMajorThreshold;
cpuMinor = serverConfig.ServerCPUMinorThreshold;
cpuMinorClear = serverConfig.ServerCPUMinorClearThreshold;
} catch (runtime_error e)
{
throw e;
}
cout << "critical water: " << serverConfig.ServerCPUCriticalThreshold << endl;
if (cpuUsage >= cpuCritical)
{
cout << "return critical: " << CRITICAL << endl;
return CRITICAL;
}
else if (cpuUsage >= cpuMajor)
{
cout << "return major: " << MAJOR << endl;
return MAJOR;
}
else if (cpuUsage >= cpuMinor)
{
cout << "return Minor: " << MINOR << endl;
return MINOR;
}
else if (cpuUsage >= cpuMinorClear)
{
cout << "return MinorClear: " << WARNING << endl;
return WARNING;
}
else
{
cout << "return Below MinorClear: " << NO_SEVERITY << endl;
return NO_SEVERITY;
}
}
