You've already forked mariadb-columnstore-engine
mirror of
https://github.com/mariadb-corporation/mariadb-columnstore-engine.git
synced 2025-08-08 14:22:09 +03:00
958 lines
25 KiB
C++
958 lines
25 KiB
C++
/* Copyright (C) 2014 InfiniDB, Inc.
|
|
Copyright (C) 2016 MariaDB Corporation
|
|
This program is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU General Public License
|
|
as published by the Free Software Foundation; version 2 of
|
|
the License.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
|
|
MA 02110-1301, USA. */
|
|
|
|
#include <string>
|
|
#include <vector>
|
|
#include <unistd.h>
|
|
#include <fstream>
|
|
#include <algorithm>
|
|
#include <iterator>
|
|
#include <stdio.h>
|
|
|
|
#include <readline/readline.h>
|
|
|
|
#include "configcpp.h"
|
|
using namespace config;
|
|
|
|
using namespace std;
|
|
|
|
#include "liboamcpp.h"
|
|
using namespace oam;
|
|
|
|
#include "helpers.h"
|
|
|
|
extern string mysqlpw;
|
|
string pwprompt = " ";
|
|
|
|
string masterLogFile = oam::UnassignedName;
|
|
string masterLogPos = oam::UnassignedName;
|
|
string prompt;
|
|
|
|
const char* pcommand = 0;
|
|
|
|
extern string installDir;
|
|
extern bool noPrompting;
|
|
|
|
namespace installer
|
|
{
|
|
|
|
const char* callReadline(string prompt)
|
|
{
|
|
if ( !noPrompting )
|
|
{
|
|
const char* ret = readline(prompt.c_str());
|
|
if( ret == 0 )
|
|
exit(1);
|
|
return ret;
|
|
}
|
|
else
|
|
{
|
|
cout << prompt << endl;
|
|
return "";
|
|
}
|
|
}
|
|
|
|
void callFree(const char* )
|
|
{
|
|
if ( !noPrompting )
|
|
free((void*)pcommand);
|
|
pcommand = 0;
|
|
}
|
|
|
|
|
|
|
|
bool waitForActive()
|
|
{
|
|
Oam oam;
|
|
|
|
const string cmd = installDir + "/bin/mcsadmin getsystemstatus > /tmp/wait.log";
|
|
system(cmd.c_str());
|
|
|
|
for ( int i = 0 ; i < 120 ; i ++ )
|
|
{
|
|
if (oam.checkLogStatus("/tmp/wait.log", "System ACTIVE") )
|
|
return true;
|
|
if ( oam.checkLogStatus("/tmp/wait.log", "System FAILED") )
|
|
return false;
|
|
cout << ".";
|
|
cout.flush();
|
|
sleep (10);
|
|
system(cmd.c_str());
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void dbrmDirCheck()
|
|
{
|
|
|
|
const string fname = installDir + "/etc/Columnstore.xml.rpmsave";
|
|
ifstream oldFile (fname.c_str());
|
|
if (!oldFile) return;
|
|
|
|
string SystemSection = "SystemConfig";
|
|
Config* sysConfig = Config::makeConfig();
|
|
Config* sysConfigPrev = Config::makeConfig(fname);
|
|
|
|
string dbrmroot = "";
|
|
string dbrmrootPrev = "";
|
|
|
|
try {
|
|
dbrmroot = sysConfig->getConfig(SystemSection, "DBRMRoot");
|
|
dbrmrootPrev = sysConfigPrev->getConfig(SystemSection, "DBRMRoot");
|
|
}
|
|
catch(const std::exception &exc)
|
|
{
|
|
std::cerr << exc.what() << std::endl;
|
|
}
|
|
|
|
if ( dbrmrootPrev.empty() )
|
|
return;
|
|
|
|
if ( dbrmroot == dbrmrootPrev )
|
|
return;
|
|
|
|
string dbrmrootDir = "";
|
|
string dbrmrootPrevDir = "";
|
|
|
|
string::size_type pos = dbrmroot.find("/BRM_saves",0);
|
|
if (pos != string::npos)
|
|
//get directory path
|
|
dbrmrootDir = dbrmroot.substr(0,pos);
|
|
else
|
|
{
|
|
return;
|
|
}
|
|
|
|
pos = dbrmrootPrev.find("/BRM_saves",0);
|
|
if (pos != string::npos)
|
|
//get directory path
|
|
dbrmrootPrevDir = dbrmrootPrev.substr(0,pos);
|
|
else
|
|
{
|
|
return;
|
|
}
|
|
|
|
// return if prev directory doesn't exist
|
|
ifstream File (dbrmrootPrevDir.c_str());
|
|
if (!File)
|
|
return;
|
|
|
|
string dbrmrootCurrent = dbrmroot + "_current";
|
|
string dbrmrootCurrentPrev = dbrmrootPrev + "_current";
|
|
|
|
// return if prev current file doesn't exist
|
|
ifstream File1 (dbrmrootCurrentPrev.c_str());
|
|
if (!File1)
|
|
return;
|
|
|
|
string cmd;
|
|
// check if current file does't exist
|
|
// if not, copy prev files to current directory
|
|
ifstream File2 (dbrmrootCurrent.c_str());
|
|
if (!File2) {
|
|
cout << endl << "===== DBRM Data File Directory Check =====" << endl << endl;
|
|
cmd = "/bin/cp -rpf " + dbrmrootPrevDir + "/* " + dbrmrootDir + "/.";
|
|
system(cmd.c_str());
|
|
|
|
//update the current file hardcoded path
|
|
ifstream oldFile (dbrmrootCurrent.c_str());
|
|
if (oldFile) {
|
|
char line[200];
|
|
oldFile.getline(line, 200);
|
|
string dbrmFile = line;
|
|
|
|
string::size_type pos = dbrmFile.find("/BRM_saves",0);
|
|
if (pos != string::npos)
|
|
dbrmFile = dbrmrootDir + dbrmFile.substr(pos,80);
|
|
|
|
unlink (dbrmrootCurrent.c_str());
|
|
ofstream newFile (dbrmrootCurrent.c_str());
|
|
|
|
string cmd = "echo " + dbrmFile + " > " + dbrmrootCurrent;
|
|
system(cmd.c_str());
|
|
|
|
newFile.close();
|
|
}
|
|
|
|
cmd = "mv -f " + dbrmrootPrevDir + " " + dbrmrootPrevDir + ".old";
|
|
system(cmd.c_str());
|
|
cout << endl << "DBRM data files were copied from dbrm directory" << endl;
|
|
cout << dbrmrootPrevDir << " to current directory of " << dbrmrootDir << "." << endl;
|
|
cout << "The old dbrm directory was renamed to " << dbrmrootPrevDir << ".old ." << endl;
|
|
}
|
|
else
|
|
{
|
|
string start = "y";
|
|
cout << endl << "===== DBRM Data File Directory Check =====" << endl << endl;
|
|
cout << endl << "DBRM data files were found in " << dbrmrootPrevDir << endl;
|
|
cout << "and in the new location " << dbrmrootDir << "." << endl << endl;
|
|
cout << "Make sure that the correct set of files are in the new location." << endl;
|
|
cout << "Then rename the directory " << dbrmrootPrevDir << " to " << dbrmrootPrevDir << ".old" << endl;
|
|
cout << "If the files were copied from " << dbrmrootPrevDir << " to " << dbrmrootDir << endl;
|
|
cout << "you will need to edit the file BRM_saves_current to contain the current path of" << endl;
|
|
cout << dbrmrootDir << endl << endl;
|
|
cout << "Please reference the MariDB Columnstore Installation Guide on Upgrade Installs for" << endl;
|
|
cout << "addition information, if needed." << endl << endl;
|
|
|
|
while(true)
|
|
{
|
|
string answer = "n";
|
|
prompt = "Enter 'y' when you are ready to continue > ";
|
|
pcommand = callReadline(prompt.c_str());
|
|
if (pcommand)
|
|
{
|
|
if (strlen(pcommand) > 0) answer = pcommand;
|
|
callFree(pcommand);
|
|
pcommand = 0;
|
|
}
|
|
if ( answer == "y" )
|
|
break;
|
|
else
|
|
cout << "Invalid Entry, please enter 'y' for yes" << endl;
|
|
}
|
|
}
|
|
|
|
cmd = "chmod 755 -R " + installDir + "/data1/systemFiles/dbrm > /dev/null 2>&1";
|
|
system(cmd.c_str());
|
|
|
|
return;
|
|
}
|
|
|
|
void mysqlSetup()
|
|
{
|
|
Oam oam;
|
|
string cmd;
|
|
cmd = installDir + "/bin/post-mysqld-install --installdir=" + installDir + " > /tmp/post-mysqld-install.log 2>&1";
|
|
int rtnCode = system(cmd.c_str());
|
|
if (WEXITSTATUS(rtnCode) != 0)
|
|
cout << "Error running post-mysqld-install, check /tmp/post-mysqld-install.log" << endl;
|
|
else
|
|
cout << "post-mysqld-install Successfully Completed" << endl;
|
|
|
|
int user;
|
|
bool rootUser = true;
|
|
user = getuid();
|
|
if (user != 0)
|
|
rootUser = false;
|
|
|
|
string HOME = "/root";
|
|
if (!rootUser) {
|
|
char* p= getenv("HOME");
|
|
if (p && *p)
|
|
HOME = p;
|
|
}
|
|
|
|
//check for password set
|
|
//start in the same way that mysqld will be started normally.
|
|
try {
|
|
oam.actionMysqlCalpont(MYSQL_START);
|
|
}
|
|
catch(const std::exception &exc)
|
|
{
|
|
std::cerr << exc.what() << std::endl;
|
|
}
|
|
sleep(2);
|
|
|
|
for (;;)
|
|
{
|
|
// 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 + pwprompt + " -e 'status' > /tmp/idbmysql.log 2>&1";
|
|
system(cmd.c_str());
|
|
|
|
if (oam.checkLogStatus("/tmp/idbmysql.log", "ERROR 1045") ) {
|
|
//check and get password
|
|
string mysqlpw = oam::UnassignedName;
|
|
try {
|
|
mysqlpw = oam.getMySQLPassword(false);
|
|
cout << "NOTE: Using MariaDB Columnstore password from " + HOME + "/.my.cnf" << endl;
|
|
}
|
|
catch (...)
|
|
{
|
|
cout << endl << "MariDB Columnstore login failure, password is assigned. Need MariaDB Columnstore password configuration file " + HOME + "/.my.cnf on local module" << endl;
|
|
exit(1);
|
|
}
|
|
|
|
mysqlpw = "'" + mysqlpw + "'";
|
|
pwprompt = "--password=" + mysqlpw;
|
|
|
|
try {
|
|
oam.setSystemConfig("MySQLPasswordConfig", "y");
|
|
}
|
|
catch(const std::exception &exc)
|
|
{
|
|
std::cerr << exc.what() << std::endl;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (!oam.checkLogStatus("/tmp/idbmysql.log", "Columnstore") ) {
|
|
cout << endl << "ERROR: MariaDB Columnstore runtime error, exit..." << endl << endl;
|
|
system("cat /tmp/idbmysql.log");
|
|
exit (1);
|
|
}
|
|
else
|
|
{
|
|
try {
|
|
oam.actionMysqlCalpont(MYSQL_STOP);
|
|
}
|
|
catch(const std::exception &exc)
|
|
{
|
|
std::cerr << exc.what() << std::endl;
|
|
}
|
|
unlink("/tmp/idbmysql.log");
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
cmd = installDir + "/bin/post-mysql-install " + pwprompt + " --installdir=" + installDir + " > /tmp/post-mysql-install.log";;
|
|
rtnCode = system(cmd.c_str());
|
|
if (WEXITSTATUS(rtnCode) == 2)
|
|
cout << "Error running post-mysql-install, password is needed. check " + HOME + "/.my.cnf " << endl;
|
|
else
|
|
if (WEXITSTATUS(rtnCode) == 1)
|
|
cout << "Error running post-mysql-install, /tmp/post-mysql-install.log" << endl;
|
|
else
|
|
cout << "post-mysql-install Successfully Completed" << endl;
|
|
|
|
return;
|
|
}
|
|
|
|
/******************************************************************************************
|
|
* @brief sendUpgradeRequest
|
|
*
|
|
* purpose: send Upgrade Request Msg to all ACTIVE UMs
|
|
*
|
|
*
|
|
******************************************************************************************/
|
|
int sendUpgradeRequest(int IserverTypeInstall, bool pmwithum)
|
|
{
|
|
Oam oam;
|
|
|
|
while(true)
|
|
{
|
|
try
|
|
{
|
|
ProcessStatus procstat;
|
|
oam.getProcessStatus("WriteEngineServer", "pm1", procstat);
|
|
if ( procstat.ProcessOpState == oam::ACTIVE)
|
|
break;
|
|
}
|
|
catch(const std::exception &exc)
|
|
{
|
|
std::cerr << exc.what() << std::endl;
|
|
}
|
|
}
|
|
|
|
SystemModuleTypeConfig systemmoduletypeconfig;
|
|
|
|
try{
|
|
oam.getSystemConfig(systemmoduletypeconfig);
|
|
}
|
|
catch(const std::exception &exc)
|
|
{
|
|
std::cerr << exc.what() << std::endl;
|
|
}
|
|
|
|
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 ) ||
|
|
( moduleType == "pm" && pmwithum ) ) {
|
|
|
|
DeviceNetworkList::iterator pt = systemmoduletypeconfig.moduletypeconfig[i].ModuleNetworkList.begin();
|
|
for ( ; pt != systemmoduletypeconfig.moduletypeconfig[i].ModuleNetworkList.end(); pt++)
|
|
{
|
|
int opState = oam::ACTIVE;
|
|
bool degraded;
|
|
try {
|
|
oam.getModuleStatus((*pt).DeviceName, opState, degraded);
|
|
|
|
if (opState == oam::ACTIVE ||
|
|
opState == oam::DEGRADED) {
|
|
returnStatus = sendMsgProcMon( (*pt).DeviceName, msg, requestID, 30 );
|
|
|
|
if ( returnStatus != API_SUCCESS) {
|
|
cout << "ERROR: Error return in running the MariDB Columnstore Upgrade, check /tmp/upgrade*.logs on " << (*pt).DeviceName << endl;
|
|
return returnStatus;
|
|
}
|
|
}
|
|
}
|
|
catch(const std::exception &exc)
|
|
{
|
|
std::cerr << exc.what() << std::endl;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return returnStatus;
|
|
}
|
|
|
|
/******************************************************************************************
|
|
* @brief sendReplicationRequest
|
|
*
|
|
* purpose: send Upgrade Request Msg to all ACTIVE UMs
|
|
*
|
|
*
|
|
******************************************************************************************/
|
|
int sendReplicationRequest(int IserverTypeInstall, std::string password, std::string port, bool pmwithum)
|
|
{
|
|
Oam oam;
|
|
|
|
SystemModuleTypeConfig systemmoduletypeconfig;
|
|
|
|
try{
|
|
oam.getSystemConfig(systemmoduletypeconfig);
|
|
}
|
|
catch(const std::exception &exc)
|
|
{
|
|
std::cerr << exc.what() << std::endl;
|
|
}
|
|
|
|
//get Primary (Master) UM
|
|
string masterModule = oam::UnassignedName;
|
|
try {
|
|
oam.getSystemConfig("PrimaryUMModuleName", masterModule);
|
|
}
|
|
catch(...) {
|
|
masterModule = oam::UnassignedName;
|
|
}
|
|
|
|
if ( masterModule == oam::UnassignedName )
|
|
{
|
|
// use default setting
|
|
masterModule = "um1";
|
|
if ( IserverTypeInstall == oam::INSTALL_COMBINE_DM_UM_PM )
|
|
masterModule = "pm1";
|
|
}
|
|
|
|
int returnStatus = oam::API_SUCCESS;
|
|
|
|
bool masterDone = false;
|
|
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;
|
|
|
|
DeviceNetworkList::iterator pt = systemmoduletypeconfig.moduletypeconfig[i].ModuleNetworkList.begin();
|
|
for ( ; pt != systemmoduletypeconfig.moduletypeconfig[i].ModuleNetworkList.end(); )
|
|
{
|
|
// we want to do master first
|
|
if ( ( (*pt).DeviceName == masterModule && !masterDone ) ||
|
|
( (*pt).DeviceName != masterModule && masterDone ) )
|
|
{
|
|
int opState = oam::ACTIVE;
|
|
bool degraded;
|
|
try {
|
|
oam.getModuleStatus((*pt).DeviceName, opState, degraded);
|
|
|
|
if (opState == oam::ACTIVE ||
|
|
opState == oam::DEGRADED) {
|
|
if ( (*pt).DeviceName == masterModule )
|
|
{
|
|
// set for Master MySQL DB distrubution to slaves
|
|
ByteStream msg1;
|
|
ByteStream::byte requestID = oam::MASTERDIST;
|
|
msg1 << requestID;
|
|
msg1 << password;
|
|
msg1 << "all"; // dist to all slave modules
|
|
|
|
returnStatus = sendMsgProcMon( (*pt).DeviceName, msg1, requestID, 600 );
|
|
|
|
if ( returnStatus != API_SUCCESS) {
|
|
cout << "ERROR: Error return in running the MariaDB Columnstore Master DB Distribute, check /tmp/master-dist.logs on " << masterModule << endl;
|
|
return returnStatus;
|
|
}
|
|
|
|
// set for master repl request
|
|
ByteStream msg;
|
|
requestID = oam::MASTERREP;
|
|
msg << requestID;
|
|
|
|
returnStatus = sendMsgProcMon( (*pt).DeviceName, msg, requestID, 30 );
|
|
|
|
if ( returnStatus != API_SUCCESS) {
|
|
cout << "ERROR: Error return in running the MariaDB Columnstore Master replication, check /tmp/master-rep*.logs on " << masterModule << endl;
|
|
return returnStatus;
|
|
}
|
|
|
|
masterDone = true;
|
|
pt = systemmoduletypeconfig.moduletypeconfig[i].ModuleNetworkList.begin();
|
|
}
|
|
else
|
|
{ // set for slave repl request
|
|
// don't do PMs unless PMwithUM flag is set
|
|
string moduleType = (*pt).DeviceName.substr(0,MAX_MODULE_TYPE_SIZE);
|
|
if ( moduleType == "pm" && !pmwithum ) {
|
|
pt++;
|
|
continue;
|
|
}
|
|
|
|
ByteStream msg;
|
|
ByteStream::byte requestID = oam::SLAVEREP;
|
|
msg << requestID;
|
|
|
|
if ( masterLogFile == oam::UnassignedName ||
|
|
masterLogPos == oam::UnassignedName )
|
|
return API_FAILURE;
|
|
|
|
msg << masterLogFile;
|
|
msg << masterLogPos;
|
|
msg << port;
|
|
|
|
returnStatus = sendMsgProcMon( (*pt).DeviceName, msg, requestID, 30 );
|
|
|
|
if ( returnStatus != API_SUCCESS) {
|
|
cout << "ERROR: Error return in running the MariaDB Columnstore Slave replication, check /tmp/slave-rep*.logs on " << (*pt).DeviceName << endl;
|
|
return returnStatus;
|
|
}
|
|
|
|
pt++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
cout << "ERROR: Module not Active, replication not done on " << (*pt).DeviceName << endl;
|
|
pt++;
|
|
}
|
|
}
|
|
catch(const std::exception &exc)
|
|
{
|
|
std::cerr << exc.what() << std::endl;
|
|
}
|
|
}
|
|
else
|
|
pt++;
|
|
}
|
|
}
|
|
return returnStatus;
|
|
}
|
|
|
|
|
|
/******************************************************************************************
|
|
* @brief sendMsgProcMon
|
|
*
|
|
* purpose: Sends a Msg to ProcMon
|
|
*
|
|
******************************************************************************************/
|
|
int sendMsgProcMon( std::string module, ByteStream msg, int requestID, int timeout )
|
|
{
|
|
string msgPort = module + "_ProcessMonitor";
|
|
int returnStatus = API_FAILURE;
|
|
Oam oam;
|
|
|
|
// do a ping test to determine a quick failure
|
|
Config* sysConfig = Config::makeConfig();
|
|
|
|
string IPAddr = sysConfig->getConfig(msgPort, "IPAddr");
|
|
|
|
if ( IPAddr == oam::UnassignedIpAddr ) {
|
|
return returnStatus;
|
|
}
|
|
|
|
string cmdLine = "ping ";
|
|
string cmdOption = " -w 1 >> /dev/null";
|
|
string cmd = cmdLine + IPAddr + cmdOption;
|
|
if ( system(cmd.c_str()) != 0) {
|
|
//ping failure
|
|
return returnStatus;
|
|
}
|
|
|
|
try
|
|
{
|
|
MessageQueueClient mqRequest(msgPort);
|
|
mqRequest.write(msg);
|
|
|
|
if ( timeout > 0 ) {
|
|
// wait for response
|
|
ByteStream::byte returnACK;
|
|
ByteStream::byte returnRequestID;
|
|
ByteStream::byte requestStatus;
|
|
ByteStream receivedMSG;
|
|
|
|
struct timespec ts = { timeout, 0 };
|
|
|
|
// get current time in seconds
|
|
time_t startTimeSec;
|
|
time (&startTimeSec);
|
|
|
|
while(true)
|
|
{
|
|
try {
|
|
receivedMSG = mqRequest.read(&ts);
|
|
}
|
|
catch (const std::exception &exc)
|
|
{
|
|
std::cerr << exc.what() << std::endl;
|
|
return returnStatus;
|
|
}
|
|
|
|
if (receivedMSG.length() > 0) {
|
|
receivedMSG >> returnACK;
|
|
receivedMSG >> returnRequestID;
|
|
receivedMSG >> requestStatus;
|
|
|
|
if ( requestID == oam::MASTERREP )
|
|
{
|
|
receivedMSG >> masterLogFile;
|
|
receivedMSG >> masterLogPos;
|
|
}
|
|
|
|
if ( returnACK == oam::ACK && returnRequestID == requestID) {
|
|
// ACK for this request
|
|
returnStatus = requestStatus;
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{ //api timeout occurred, check if retry should be done
|
|
// get current time in seconds
|
|
time_t endTimeSec;
|
|
time (&endTimeSec);
|
|
if ( timeout <= (endTimeSec - startTimeSec) ) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
returnStatus = oam::API_SUCCESS;
|
|
|
|
mqRequest.shutdown();
|
|
}
|
|
catch(const std::exception &exc)
|
|
{
|
|
std::cerr << exc.what() << std::endl;
|
|
}
|
|
|
|
return returnStatus;
|
|
}
|
|
|
|
void checkFilesPerPartion(int DBRootCount, Config* sysConfig)
|
|
{
|
|
// check 'files per parition' with number of dbroots
|
|
// 'files per parition' need to be a multiple of dbroots
|
|
// update if no database already exist
|
|
// issue warning if database exist
|
|
|
|
Oam oam;
|
|
string SystemSection = "SystemConfig";
|
|
|
|
string dbRoot = installDir + "/data1";
|
|
|
|
try {
|
|
dbRoot = sysConfig->getConfig(SystemSection, "DBRoot1");
|
|
}
|
|
catch(const std::exception &exc)
|
|
{
|
|
std::cerr << exc.what() << std::endl;
|
|
}
|
|
|
|
dbRoot = dbRoot + "/000.dir";
|
|
|
|
float FilesPerColumnPartition = 4;
|
|
try {
|
|
string tmp = sysConfig->getConfig("ExtentMap", "FilesPerColumnPartition");
|
|
FilesPerColumnPartition = atoi(tmp.c_str());
|
|
}
|
|
catch(const std::exception &exc)
|
|
{
|
|
std::cerr << exc.what() << std::endl;
|
|
}
|
|
|
|
if ( fmod(FilesPerColumnPartition , (float) DBRootCount) != 0 ) {
|
|
ifstream oldFile (dbRoot.c_str());
|
|
if (!oldFile) {
|
|
//set FilesPerColumnPartition == DBRootCount
|
|
sysConfig->setConfig("ExtentMap", "FilesPerColumnPartition", oam.itoa(DBRootCount));
|
|
|
|
cout << endl << "***************************************************************************" << endl;
|
|
cout << "NOTE: Mismatch between FilesPerColumnPartition (" + oam.itoa((int)FilesPerColumnPartition) + ") and number of DBRoots (" + oam.itoa(DBRootCount) + ")" << endl;
|
|
cout << " Setting FilesPerColumnPartition = number of DBRoots" << endl;
|
|
cout << "***************************************************************************" << endl;
|
|
}
|
|
else
|
|
{
|
|
cout << endl << "***************************************************************************" << endl;
|
|
cout << "WARNING: Mismatch between FilesPerColumnPartition (" + oam.itoa((int)FilesPerColumnPartition) + ") and number of DBRoots (" + oam.itoa(DBRootCount) + ")" << endl;
|
|
cout << " Database already exist, going forward could corrupt the database" << endl;
|
|
cout << " Please Contact Customer Support" << endl;
|
|
cout << "***************************************************************************" << endl;
|
|
exit (1);
|
|
}
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
void checkMysqlPort( std::string& mysqlPort, Config* sysConfig )
|
|
{
|
|
Oam oam;
|
|
|
|
while(true)
|
|
{
|
|
string cmd = "netstat -na | grep -e :" + mysqlPort + "[[:space:]] | grep LISTEN > /tmp/mysqlport";
|
|
|
|
system(cmd.c_str());
|
|
string fileName = "/tmp/mysqlport";
|
|
ifstream oldFile (fileName.c_str());
|
|
if (oldFile) {
|
|
oldFile.seekg(0, std::ios::end);
|
|
int size = oldFile.tellg();
|
|
if ( size != 0 ) {
|
|
if ( noPrompting ) {
|
|
cout << endl << "The MariaDB Columnstore port of '" + mysqlPort + "' is already in-use" << endl;
|
|
cout << "For No-prompt install, use the command line argument of 'port' to enter a different number" << endl;
|
|
exit(1);
|
|
}
|
|
|
|
cout << "The MariaDB Columnstore port of '" + mysqlPort + "' is already in-use on local server" << endl;
|
|
|
|
while(true)
|
|
{
|
|
prompt = "Enter a different port number > ";
|
|
pcommand = callReadline(prompt.c_str());
|
|
if (pcommand)
|
|
{
|
|
if (strlen(pcommand) > 0) mysqlPort = pcommand;
|
|
callFree(pcommand);
|
|
pcommand = 0;
|
|
}
|
|
|
|
if ( atoi(mysqlPort.c_str()) < 1000 || atoi(mysqlPort.c_str()) > 9999)
|
|
{
|
|
cout << " ERROR: Invalid MariaDB Columnstore Port ID supplied, must be between 1000-9999" << endl;
|
|
}
|
|
else
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
cout << endl;
|
|
|
|
try {
|
|
sysConfig->setConfig("Installation", "MySQLPort", mysqlPort);
|
|
}
|
|
catch(const std::exception &exc)
|
|
{
|
|
std::cerr << exc.what() << std::endl;
|
|
}
|
|
|
|
if ( !writeConfig(sysConfig) ) {
|
|
cout << "ERROR: Failed trying to update MariDB Columnstore System Configuration file" << endl;
|
|
exit(1);
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
break;
|
|
}
|
|
|
|
// set mysql password
|
|
oam.changeMyCnf( "port", mysqlPort );
|
|
}
|
|
|
|
void checkSystemMySQLPort(std::string& mysqlPort, Config* sysConfig, std::string USER, std::string password, ChildModuleList childmodulelist, int IserverTypeInstall, bool pmwithum)
|
|
{
|
|
Oam oam;
|
|
|
|
bool inUse = false;
|
|
|
|
while(true)
|
|
{
|
|
string localnetstat = "netstat -na | grep -e :" + mysqlPort + "[[:space:]] | grep LISTEN > /tmp/mysqlport";
|
|
string remotenetstat = "netstat -na | grep -e :" + mysqlPort + "[[:space:]] | grep LISTEN";
|
|
|
|
//first check local mysql, if needed
|
|
if ( ( IserverTypeInstall == oam::INSTALL_COMBINE_DM_UM_PM ) ||
|
|
( ( IserverTypeInstall != oam::INSTALL_COMBINE_DM_UM_PM ) && pmwithum ) )
|
|
{
|
|
system(localnetstat.c_str());
|
|
string fileName = "/tmp/mysqlport";
|
|
ifstream oldFile (fileName.c_str());
|
|
|
|
if (oldFile) {
|
|
oldFile.seekg(0, std::ios::end);
|
|
int size = oldFile.tellg();
|
|
if ( size != 0 ) {
|
|
if ( noPrompting ) {
|
|
cout << endl << "The MariaDB Columnstore port of '" + mysqlPort + "' is already in-use" << endl;
|
|
cout << "For No-prompt install, use the command line argument of 'port' to enter a different number" << endl;
|
|
exit(1);
|
|
}
|
|
else
|
|
inUse = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
// if not inuse by local, go check remote servers
|
|
string inUseServer = "";
|
|
if ( !inUse )
|
|
{
|
|
ChildModuleList::iterator list1 = childmodulelist.begin();
|
|
for (; list1 != childmodulelist.end() ; list1++)
|
|
{
|
|
string remoteModuleName = (*list1).moduleName;
|
|
string remoteModuleIP = (*list1).moduleIP;
|
|
string remoteHostName = (*list1).hostName;
|
|
string remoteModuleType = remoteModuleName.substr(0,MAX_MODULE_TYPE_SIZE);
|
|
|
|
if ( remoteModuleType == "um" ||
|
|
(remoteModuleType == "pm" && IserverTypeInstall == oam::INSTALL_COMBINE_DM_UM_PM) ||
|
|
(remoteModuleType == "pm" && pmwithum) )
|
|
{
|
|
|
|
string cmd = installDir + "/bin/remote_command_verify.sh " + remoteModuleIP + " " + " " + USER + " " + password + " '" + remotenetstat + "' tcp error 5 0 > /dev/null 2>&1";
|
|
int rtnCode = system(cmd.c_str());
|
|
if (WEXITSTATUS(rtnCode) == 0) {
|
|
if ( noPrompting ) {
|
|
cout << endl << "The MariaDB Columnstore port of '" + mysqlPort + "' is already in-use on " << remoteModuleName << endl;
|
|
cout << "For No-prompt install, use the command line argument of 'port' to enter a different number" << endl;
|
|
cout << "exiting..." << endl;
|
|
exit(1);
|
|
}
|
|
else
|
|
{
|
|
inUseServer = remoteModuleName;
|
|
inUse = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( inUse )
|
|
{
|
|
cout << endl << "The MariaDB Columnstore port of '" + mysqlPort + "' is already in-use on " << inUseServer << endl;
|
|
|
|
while(true)
|
|
{
|
|
prompt = "Enter a different port number > ";
|
|
pcommand = callReadline(prompt.c_str());
|
|
if (pcommand)
|
|
{
|
|
if (strlen(pcommand) > 0) mysqlPort = pcommand;
|
|
callFree(pcommand);
|
|
pcommand = 0;
|
|
}
|
|
|
|
if ( atoi(mysqlPort.c_str()) < 1000 || atoi(mysqlPort.c_str()) > 9999)
|
|
{
|
|
cout << " ERROR: Invalid MariaDB Columnstore Port ID supplied, must be between 1000-9999" << endl;
|
|
}
|
|
else
|
|
break;
|
|
}
|
|
|
|
inUse = false;
|
|
}
|
|
else
|
|
{
|
|
cout << endl;
|
|
|
|
try {
|
|
sysConfig->setConfig("Installation", "MySQLPort", mysqlPort);
|
|
}
|
|
catch(const std::exception &exc)
|
|
{
|
|
std::cerr << exc.what() << std::endl;
|
|
}
|
|
|
|
if ( !writeConfig(sysConfig) ) {
|
|
cout << "ERROR: Failed trying to update MariDB Columnstore System Configuration file" << endl;
|
|
exit(1);
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
// set mysql password
|
|
oam.changeMyCnf( "port", mysqlPort );
|
|
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* writeConfig
|
|
*/
|
|
bool writeConfig( Config* sysConfig )
|
|
{
|
|
for ( int i = 0 ; i < 3 ; i++ )
|
|
{
|
|
try {
|
|
sysConfig->write();
|
|
return true;
|
|
}
|
|
catch(const std::exception &exc)
|
|
{
|
|
std::cerr << exc.what() << std::endl;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
std::string getmysqlpw(std::string logFile)
|
|
{
|
|
ifstream oldFile (logFile.c_str());
|
|
if (oldFile) {
|
|
char line[200];
|
|
string buf;
|
|
while (oldFile.getline(line, 200))
|
|
{
|
|
buf = line;
|
|
string::size_type pos = buf.find("mysqlpw=",0);
|
|
if (pos != string::npos)
|
|
{
|
|
string mysqlpw = buf.substr(pos+8, 80);
|
|
// unlink(logFile);
|
|
return mysqlpw;
|
|
}
|
|
}
|
|
}
|
|
|
|
return oam::UnassignedName;
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|