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();
}
/*****************************************************************************************
* @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
}
CreateTableProcessor::DDLResult CreateTableProcessor::processPackage(
ddlpackage::CreateTableStatement& createTableStmt)
{
SUMMARY_INFO("CreateTableProcessor::processPackage");
DDLResult result;
BRM::TxnID txnID;
txnID.id= fTxnid.id;
txnID.valid= fTxnid.valid;
result.result = NO_ERROR;
int rc1 = 0;
rc1 = fDbrm->isReadWrite();
if (rc1 != 0 )
{
Message::Args args;
Message message(9);
args.add("Unable to execute the statement due to DBRM is read only");
message.format(args);
result.result = CREATE_ERROR;
result.message = message;
fSessionManager.rolledback(txnID);
return result;
}
DETAIL_INFO(createTableStmt);
ddlpackage::TableDef& tableDef = *createTableStmt.fTableDef;
//If schema = CALPONTSYS, do not create table
boost::algorithm::to_lower(tableDef.fQualifiedName->fSchema);
if (tableDef.fQualifiedName->fSchema == CALPONT_SCHEMA)
{
//release the transaction
fSessionManager.rolledback(txnID);
return result;
}
// Commit current transaction.
// all DDL statements cause an implicut commit
VERBOSE_INFO("Getting current txnID");
//Check whether the table is existed already
boost::shared_ptr<CalpontSystemCatalog> systemCatalogPtr =
CalpontSystemCatalog::makeCalpontSystemCatalog(createTableStmt.fSessionID);
execplan::CalpontSystemCatalog::TableName tableName;
tableName.schema = tableDef.fQualifiedName->fSchema;
tableName.table = tableDef.fQualifiedName->fName;
execplan::CalpontSystemCatalog::ROPair roPair;
roPair.objnum = 0;
ByteStream::byte rc = 0;
/** @Bug 217 */
/** @Bug 225 */
try
{
roPair = systemCatalogPtr->tableRID(tableName);
}
catch (IDBExcept &ie)
{
// TODO: What is and is not an error here?
if (ie.errorCode() == ERR_DATA_OFFLINE)
{
//release transaction
fSessionManager.rolledback(txnID);
// Return the error for display to user
Message::Args args;
Message message(9);
args.add(ie.what());
message.format(args);
result.result = CREATE_ERROR;
result.message = message;
return result;
}
else if ( ie.errorCode() == ERR_TABLE_NOT_IN_CATALOG)
{
roPair.objnum = 0;
}
else //error out
{
//release transaction
fSessionManager.rolledback(txnID);
// Return the error for display to user
Message::Args args;
Message message(9);
args.add(ie.what());
message.format(args);
result.result = CREATE_ERROR;
result.message = message;
return result;
}
}
catch (std::exception& ex) //error out
{
//release transaction
fSessionManager.rolledback(txnID);
// Return the error for display to user
Message::Args args;
Message message(9);
args.add(ex.what());
message.format(args);
result.result = CREATE_ERROR;
result.message = message;
return result;
}
catch (...) //error out
{
//release transaction
fSessionManager.rolledback(txnID);
// Return the error for display to user
Message::Args args;
Message message(9);
args.add("Unknown exception caught when checking if the table name is already in use.");
message.format(args);
result.result = CREATE_ERROR;
result.message = message;
return result;
}
//This is a current db bug, it should not turn OID is it cannot find
if (roPair.objnum >= 3000)
{
#ifdef _MSC_VER
//FIXME: Why do we need to do this???
systemCatalogPtr->flushCache();
try { roPair = systemCatalogPtr->tableRID(tableName); }
catch (...) { roPair.objnum = 0; }
if (roPair.objnum < 3000)
goto keepGoing;
#endif
Message::Args args;
Message message(9);
args.add("Internal create table error for");
args.add(tableName.toString());
args.add(": table already exists");
args.add("(your schema is probably out-of-sync)");
message.format(args);
result.result = CREATE_ERROR;
result.message = message;
//release the transaction
fSessionManager.rolledback(txnID);
return result;
}
#ifdef _MSC_VER
keepGoing:
#endif
// Start a new transaction
VERBOSE_INFO("Starting a new transaction");
string stmt = createTableStmt.fSql + "|" + tableDef.fQualifiedName->fSchema +"|";
SQLLogger logger(stmt, fDDLLoggingId, createTableStmt.fSessionID, txnID.id);
std::string err;
execplan::ObjectIDManager fObjectIDManager;
OamCache * oamcache = OamCache::makeOamCache();
string errorMsg;
//get a unique number
uint64_t uniqueId = 0;
//Bug 5070. Added exception handling
try {
uniqueId = fDbrm->getUnique64();
}
catch (std::exception& ex)
{
Message::Args args;
Message message(9);
args.add(ex.what());
message.format(args);
result.result = CREATE_ERROR;
result.message = message;
fSessionManager.rolledback(txnID);
return result;
}
catch ( ... )
{
Message::Args args;
Message message(9);
args.add("Unknown error occured while getting unique number.");
message.format(args);
result.result = CREATE_ERROR;
result.message = message;
fSessionManager.rolledback(txnID);
return result;
}
fWEClient->addQueue(uniqueId);
try
{
//Allocate tableoid table identification
VERBOSE_INFO("Allocating object ID for table");
// Allocate a object ID for each column we are about to create
VERBOSE_INFO("Allocating object IDs for columns");
uint32_t numColumns = tableDef.fColumns.size();
uint32_t numDictCols = 0;
for (unsigned i=0; i < numColumns; i++)
{
int dataType;
dataType = convertDataType(tableDef.fColumns[i]->fType->fType);
if ( (dataType == CalpontSystemCatalog::CHAR && tableDef.fColumns[i]->fType->fLength > 8) ||
(dataType == CalpontSystemCatalog::VARCHAR && tableDef.fColumns[i]->fType->fLength > 7) ||
(dataType == CalpontSystemCatalog::VARBINARY && tableDef.fColumns[i]->fType->fLength > 7) )
numDictCols++;
}
fStartingColOID = fObjectIDManager.allocOIDs(numColumns+numDictCols+1); //include column, oids,dictionary oids and tableoid
#ifdef IDB_DDL_DEBUG
cout << "Create table allocOIDs got the stating oid " << fStartingColOID << endl;
#endif
if (fStartingColOID < 0)
{
result.result = CREATE_ERROR;
errorMsg = "Error in getting objectid from oidmanager.";
Message::Args args;
Message message(9);
args.add("Create table failed due to ");
args.add(errorMsg);
message.format(args);
result.message = message;
fSessionManager.rolledback(txnID);
return result;
}
// Write the table metadata to the systemtable
VERBOSE_INFO("Writing meta data to SYSTABLE");
ByteStream bytestream;
bytestream << (ByteStream::byte)WE_SVR_WRITE_SYSTABLE;
bytestream << uniqueId;
bytestream << (uint32_t) createTableStmt.fSessionID;
bytestream << (uint32_t)txnID.id;
bytestream << (uint32_t)fStartingColOID;
bytestream << (uint32_t)createTableStmt.fTableWithAutoi;
uint16_t dbRoot;
BRM::OID_t sysOid = 1001;
//Find out where systable is
rc = fDbrm->getSysCatDBRoot(sysOid, dbRoot);
if (rc != 0)
{
result.result =(ResultCode) rc;
Message::Args args;
Message message(9);
args.add("Error while calling getSysCatDBRoot ");
args.add(errorMsg);
message.format(args);
result.message = message;
//release transaction
fSessionManager.rolledback(txnID);
return result;
}
int pmNum = 1;
bytestream << (uint32_t)dbRoot;
tableDef.serialize(bytestream);
boost::shared_ptr<messageqcpp::ByteStream> bsIn;
boost::shared_ptr<std::map<int, int> > dbRootPMMap = oamcache->getDBRootToPMMap();
pmNum = (*dbRootPMMap)[dbRoot];
try
{
fWEClient->write(bytestream, (unsigned)pmNum);
#ifdef IDB_DDL_DEBUG
cout << "create table sending We_SVR_WRITE_SYSTABLE to pm " << pmNum << endl;
#endif
while (1)
{
bsIn.reset(new ByteStream());
fWEClient->read(uniqueId, bsIn);
if ( bsIn->length() == 0 ) //read error
{
rc = NETWORK_ERROR;
errorMsg = "Lost connection to Write Engine Server while updating SYSTABLES";
break;
}
else {
*bsIn >> rc;
if (rc != 0) {
errorMsg.clear();
*bsIn >> errorMsg;
#ifdef IDB_DDL_DEBUG
cout << "Create table We_SVR_WRITE_CREATETABLEFILES: " << errorMsg << endl;
#endif
}
break;
}
}
}
catch (runtime_error& ex) //write error
{
#ifdef IDB_DDL_DEBUG
cout << "create table got exception" << ex.what() << endl;
#endif
rc = NETWORK_ERROR;
errorMsg = ex.what();
}
catch (...)
{
rc = NETWORK_ERROR;
#ifdef IDB_DDL_DEBUG
cout << "create table got unknown exception" << endl;
#endif
}
if (rc != 0)
{
result.result =(ResultCode) rc;
Message::Args args;
Message message(9);
args.add("Create table failed due to ");
args.add(errorMsg);
message.format( args );
result.message = message;
if (rc != NETWORK_ERROR)
{
rollBackTransaction( uniqueId, txnID, createTableStmt.fSessionID ); //What to do with the error code
}
//release transaction
fSessionManager.rolledback(txnID);
return result;
}
VERBOSE_INFO("Writing meta data to SYSCOLUMN");
bytestream.restart();
bytestream << (ByteStream::byte)WE_SVR_WRITE_CREATE_SYSCOLUMN;
bytestream << uniqueId;
bytestream << (uint32_t) createTableStmt.fSessionID;
bytestream << (uint32_t)txnID.id;
bytestream << numColumns;
for (unsigned i = 0; i <numColumns; ++i) {
bytestream << (uint32_t)(fStartingColOID+i+1);
}
bytestream << numDictCols;
for (unsigned i = 0; i <numDictCols; ++i) {
bytestream << (uint32_t)(fStartingColOID+numColumns+i+1);
}
uint8_t alterFlag = 0;
int colPos = 0;
bytestream << (ByteStream::byte)alterFlag;
bytestream << (uint32_t)colPos;
sysOid = 1021;
//Find out where syscolumn is
rc = fDbrm->getSysCatDBRoot(sysOid, dbRoot);
if (rc != 0)
{
result.result =(ResultCode) rc;
Message::Args args;
Message message(9);
args.add("Error while calling getSysCatDBRoot ");
args.add(errorMsg);
message.format(args);
result.message = message;
//release transaction
fSessionManager.rolledback(txnID);
return result;
}
bytestream << (uint32_t)dbRoot;
tableDef.serialize(bytestream);
pmNum = (*dbRootPMMap)[dbRoot];
try
{
fWEClient->write(bytestream, (uint32_t)pmNum);
#ifdef IDB_DDL_DEBUG
cout << "create table sending We_SVR_WRITE_SYSTABLE to pm " << pmNum << endl;
#endif
while (1)
{
bsIn.reset(new ByteStream());
fWEClient->read(uniqueId, bsIn);
if ( bsIn->length() == 0 ) //read error
{
rc = NETWORK_ERROR;
errorMsg = "Lost connection to Write Engine Server while updating SYSTABLES";
break;
}
else {
*bsIn >> rc;
if (rc != 0) {
errorMsg.clear();
*bsIn >> errorMsg;
#ifdef IDB_DDL_DEBUG
cout << "Create table We_SVR_WRITE_CREATETABLEFILES: " << errorMsg << endl;
#endif
}
break;
}
}
}
catch (runtime_error& ex) //write error
{
#ifdef IDB_DDL_DEBUG
cout << "create table got exception" << ex.what() << endl;
#endif
rc = NETWORK_ERROR;
errorMsg = ex.what();
}
catch (...)
{
rc = NETWORK_ERROR;
#ifdef IDB_DDL_DEBUG
cout << "create table got unknown exception" << endl;
#endif
}
if (rc != 0)
{
result.result =(ResultCode) rc;
Message::Args args;
Message message(9);
args.add("Create table failed due to ");
args.add(errorMsg);
message.format( args );
result.message = message;
if (rc != NETWORK_ERROR)
{
rollBackTransaction( uniqueId, txnID, createTableStmt.fSessionID ); //What to do with the error code
}
//release transaction
fSessionManager.rolledback(txnID);
return result;
}
//Get the number of tables in the database, the current table is included.
int tableCount = systemCatalogPtr->getTableCount();
//Calculate which dbroot the columns should start
DBRootConfigList dbRootList = oamcache->getDBRootNums();
uint16_t useDBRootIndex = tableCount % dbRootList.size();
//Find out the dbroot# corresponding the useDBRootIndex from oam
uint16_t useDBRoot = dbRootList[useDBRootIndex];
VERBOSE_INFO("Creating column files");
ColumnDef* colDefPtr;
ddlpackage::ColumnDefList tableDefCols = tableDef.fColumns;
ColumnDefList::const_iterator iter = tableDefCols.begin();
bytestream.restart();
bytestream << (ByteStream::byte)WE_SVR_WRITE_CREATETABLEFILES;
bytestream << uniqueId;
bytestream << (uint32_t)txnID.id;
bytestream << (numColumns + numDictCols);
unsigned colNum = 0;
unsigned dictNum = 0;
while (iter != tableDefCols.end())
{
colDefPtr = *iter;
CalpontSystemCatalog::ColDataType dataType = convertDataType(colDefPtr->fType->fType);
if (dataType == CalpontSystemCatalog::DECIMAL ||
dataType == CalpontSystemCatalog::UDECIMAL)
{
if (colDefPtr->fType->fPrecision == -1 || colDefPtr->fType->fPrecision == 0)
{
colDefPtr->fType->fLength = 8;
}
else if ((colDefPtr->fType->fPrecision > 0) && (colDefPtr->fType->fPrecision < 3))
{
colDefPtr->fType->fLength = 1;
}
else if (colDefPtr->fType->fPrecision < 5 && (colDefPtr->fType->fPrecision > 2))
{
colDefPtr->fType->fLength = 2;
}
else if (colDefPtr->fType->fPrecision > 4 && colDefPtr->fType->fPrecision < 10)
{
colDefPtr->fType->fLength = 4;
}
else if (colDefPtr->fType->fPrecision > 9 && colDefPtr->fType->fPrecision < 19)
{
colDefPtr->fType->fLength = 8;
}
}
bytestream << (fStartingColOID + (colNum++) + 1);
bytestream << (uint8_t) dataType;
bytestream << (uint8_t) false;
bytestream << (uint32_t) colDefPtr->fType->fLength;
bytestream << (uint16_t) useDBRoot;
bytestream << (uint32_t) colDefPtr->fType->fCompressiontype;
if ( (dataType == CalpontSystemCatalog::CHAR && colDefPtr->fType->fLength > 8) ||
(dataType == CalpontSystemCatalog::VARCHAR && colDefPtr->fType->fLength > 7) ||
(dataType == CalpontSystemCatalog::VARBINARY && colDefPtr->fType->fLength > 7) )
{
bytestream << (uint32_t) (fStartingColOID+numColumns+(dictNum++)+1);
bytestream << (uint8_t) dataType;
bytestream << (uint8_t) true;
bytestream << (uint32_t) colDefPtr->fType->fLength;
bytestream << (uint16_t) useDBRoot;
bytestream << (uint32_t) colDefPtr->fType->fCompressiontype;
}
++iter;
}
//@Bug 4176. save oids to a log file for cleanup after fail over.
std::vector <CalpontSystemCatalog::OID> oidList;
for (unsigned i = 0; i <numColumns; ++i)
{
oidList.push_back(fStartingColOID+i+1);
}
bytestream << numDictCols;
for (unsigned i = 0; i <numDictCols; ++i)
{
oidList.push_back(fStartingColOID+numColumns+i+1);
}
try {
createWriteDropLogFile( fStartingColOID, uniqueId, oidList );
}
catch (std::exception& ex)
{
result.result =(ResultCode) rc;
Message::Args args;
Message message(9);
args.add("Create table failed due to ");
args.add(ex.what());
message.format( args );
result.message = message;
if (rc != NETWORK_ERROR)
{
rollBackTransaction( uniqueId, txnID, createTableStmt.fSessionID ); //What to do with the error code
}
//release transaction
fSessionManager.rolledback(txnID);
return result;
}
pmNum = (*dbRootPMMap)[useDBRoot];
try
{
fWEClient->write(bytestream, pmNum);
while (1)
{
bsIn.reset(new ByteStream());
fWEClient->read(uniqueId, bsIn);
if ( bsIn->length() == 0 ) //read error
{
rc = NETWORK_ERROR;
errorMsg = "Lost connection to Write Engine Server while updating SYSTABLES";
break;
}
else {
*bsIn >> rc;
if (rc != 0) {
errorMsg.clear();
*bsIn >> errorMsg;
#ifdef IDB_DDL_DEBUG
cout << "Create table We_SVR_WRITE_CREATETABLEFILES: " << errorMsg << endl;
#endif
}
break;
}
}
if (rc != 0) {
//drop the newly created files
bytestream.restart();
bytestream << (ByteStream::byte) WE_SVR_WRITE_DROPFILES;
bytestream << uniqueId;
bytestream << (uint32_t)(numColumns+numDictCols);
for (unsigned i = 0; i < (numColumns+numDictCols); i++)
{
bytestream << (uint32_t)(fStartingColOID + i + 1);
}
fWEClient->write(bytestream, pmNum);
while (1)
{
bsIn.reset(new ByteStream());
fWEClient->read(uniqueId, bsIn);
if ( bsIn->length() == 0 ) //read error
{
break;
}
else {
break;
}
}
//@Bug 5464. Delete from extent map.
fDbrm->deleteOIDs(oidList);
}
}
catch (runtime_error&)
{
errorMsg = "Lost connection to Write Engine Server";
}
if (rc != 0)
{
rollBackTransaction( uniqueId, txnID, createTableStmt.fSessionID); //What to do with the error code
fSessionManager.rolledback(txnID);
}
else
{
commitTransaction(uniqueId, txnID);
fSessionManager.committed(txnID);
fWEClient->removeQueue(uniqueId);
deleteLogFile(DROPTABLE_LOG, fStartingColOID, uniqueId);
}
// Log the DDL statement.
logDDL(createTableStmt.fSessionID, txnID.id, createTableStmt.fSql, createTableStmt.fOwner);
}
