You've already forked mariadb-columnstore-engine
mirror of
https://github.com/mariadb-corporation/mariadb-columnstore-engine.git
synced 2025-11-03 17:13:17 +03:00
616 lines
16 KiB
C++
Executable File
616 lines
16 KiB
C++
Executable File
/* Copyright (C) 2014 InfiniDB, Inc.
|
|
|
|
This program is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU General Public License
|
|
as published by the Free Software Foundation; version 2 of
|
|
the License.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
|
|
MA 02110-1301, USA. */
|
|
|
|
/*******************************************************************************
|
|
* $Id$
|
|
*
|
|
*******************************************************************************/
|
|
|
|
/*
|
|
* we_splitterapp.cpp
|
|
*
|
|
* Created on: Oct 7, 2011
|
|
* Author: bpaul
|
|
*/
|
|
|
|
#include <unistd.h>
|
|
#include <cstdlib>
|
|
#include <csignal>
|
|
|
|
#include <string>
|
|
using namespace std;
|
|
|
|
#include <boost/uuid/uuid.hpp>
|
|
#include <boost/uuid/uuid_generators.hpp>
|
|
#include <boost/uuid/uuid_io.hpp>
|
|
|
|
#include "batchloader.h"
|
|
using namespace batchloader;
|
|
|
|
#include "we_messages.h"
|
|
#include "we_splitterapp.h"
|
|
|
|
#include "installdir.h"
|
|
|
|
static int SPLTR_EXIT_STATUS=0;
|
|
|
|
|
|
namespace WriteEngine
|
|
{
|
|
bool WESplitterApp::fContinue = true;
|
|
bool WESplitterApp::fSignaled = false;
|
|
bool WESplitterApp::fSigHup = false;
|
|
|
|
SimpleSysLog* WESplitterApp::fpSysLog = 0;
|
|
|
|
|
|
//WESplitterApp::WESplitterApp(WECmdArgs& CmdArgs) :
|
|
// fCmdArgs(CmdArgs), fDh(*this), fpSysLog(0)
|
|
WESplitterApp::WESplitterApp(WECmdArgs& CmdArgs) :
|
|
fCmdArgs(CmdArgs), fDh(*this)
|
|
{
|
|
fpSysLog = SimpleSysLog::instance();
|
|
fpSysLog->setLoggingID(logging::LoggingID(SUBSYSTEM_ID_WE_SPLIT));
|
|
setupSignalHandlers();
|
|
std::string err;
|
|
fDh.setDebugLvl(fCmdArgs.getDebugLvl());
|
|
|
|
fDh.check4CpiInvokeMode();
|
|
|
|
fCmdArgs.checkForCornerCases();
|
|
|
|
if (fCmdArgs.isCpimportInvokeMode())
|
|
{
|
|
try
|
|
{
|
|
invokeCpimport();
|
|
}
|
|
catch(std::exception& ex)
|
|
{
|
|
cout << "Invoking Mode 3" << endl;
|
|
cout << ex.what() << endl;
|
|
SPLTR_EXIT_STATUS=1;
|
|
exit(SPLTR_EXIT_STATUS);
|
|
}
|
|
exit(SPLTR_EXIT_STATUS);
|
|
}
|
|
else
|
|
{
|
|
if(fCmdArgs.isHelpMode()) fCmdArgs.usage();
|
|
|
|
if(fCmdArgs.getMultiTableCount() <= 1)
|
|
{
|
|
try
|
|
{
|
|
fDh.setup();
|
|
}
|
|
catch (std::exception& ex)
|
|
{
|
|
//err = string("Error in constructing WESplitterApp") + ex.what();
|
|
err = ex.what(); //cleaning up for BUG 4298
|
|
logging::Message::Args errMsgArgs;
|
|
errMsgArgs.add(err);
|
|
fpSysLog->logMsg(errMsgArgs,logging::LOG_TYPE_ERROR,logging::M0000);
|
|
if (!fCmdArgs.getConsoleOutput())
|
|
{
|
|
ofstream dmlFile;
|
|
ostringstream oss;
|
|
oss << "/tmp/" <<fDh.getTableOID() << ".txt";
|
|
dmlFile.open(oss.str().c_str());
|
|
if (dmlFile.is_open())
|
|
{
|
|
dmlFile << err;
|
|
dmlFile << endl;
|
|
dmlFile.close();
|
|
}
|
|
SPLTR_EXIT_STATUS=2;
|
|
}
|
|
else
|
|
SPLTR_EXIT_STATUS=1;
|
|
//cout << err << endl;
|
|
fDh.fLog.logMsg( err, MSGLVL_ERROR );
|
|
fContinue = false;
|
|
//throw runtime_error(err); BUG 4298
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
WESplitterApp::~WESplitterApp()
|
|
{
|
|
//fDh.shutdown();
|
|
usleep(1000); //1 millisec just checking
|
|
|
|
std::string aStr = "Calling WESplitterApp Destructor\n";
|
|
if(fDh.getDebugLvl()) cout << aStr << endl;
|
|
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Initialize signal handling
|
|
//------------------------------------------------------------------------------
|
|
|
|
void WESplitterApp::setupSignalHandlers()
|
|
{
|
|
#ifdef _MSC_VER
|
|
//FIXME
|
|
#else
|
|
struct sigaction sa;
|
|
memset(&sa, 0, sizeof(sa));
|
|
sa.sa_handler = WESplitterApp::onSigInterrupt;
|
|
sigaction(SIGINT, &sa, 0);
|
|
sa.sa_handler = WESplitterApp::onSigTerminate;
|
|
sigaction(SIGTERM, &sa, 0);
|
|
sa.sa_handler = SIG_IGN;
|
|
sigaction(SIGPIPE, &sa, 0);
|
|
sa.sa_handler = WESplitterApp::onSigHup;
|
|
sigaction(SIGPIPE, &sa, 0);
|
|
sa.sa_handler = WESplitterApp::onSigInterrupt;
|
|
sigaction(SIGUSR1, &sa, 0);
|
|
/*
|
|
signal(SIGPIPE, SIG_IGN);
|
|
signal(SIGINT, WESplitterApp::onSigInterrupt);
|
|
signal(SIGTERM, WESplitterApp::onSigTerminate);
|
|
signal(SIGHUP, WESplitterApp::onSigHup); */
|
|
#endif
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
// handles on signal Terminate
|
|
//------------------------------------------------------------------------------
|
|
void WESplitterApp::onSigTerminate(int aInt)
|
|
{
|
|
cout << "onSigTerminate received signal " << aInt << endl;
|
|
if(15 == aInt)
|
|
{
|
|
fSignaled = true;
|
|
}
|
|
fContinue = false; //force to call destructor
|
|
if(aInt == 1) SPLTR_EXIT_STATUS = 1;
|
|
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// handles on signal Interrupt
|
|
//------------------------------------------------------------------------------
|
|
void WESplitterApp::onSigInterrupt(int aInt)
|
|
{
|
|
//cout << "onSigInterrupt received signal " << aInt << endl;
|
|
if((2 == aInt) || (10 == aInt))
|
|
{
|
|
fSignaled = true;
|
|
//cout << "ctrl-c received" << endl;
|
|
}
|
|
fContinue = false; //force to call destructor
|
|
if(aInt == 1) SPLTR_EXIT_STATUS = 1;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// handles on signal HUP send by OAM
|
|
//------------------------------------------------------------------------------
|
|
void WESplitterApp::onSigHup(int aInt)
|
|
{
|
|
fSigHup = true;
|
|
fContinue = false;
|
|
std::string aStr = "Interrupt received...Program Exiting...";
|
|
cout << aStr << endl;
|
|
if(aInt == 1) SPLTR_EXIT_STATUS = 1;
|
|
logging::Message::Args errMsgArgs;
|
|
errMsgArgs.add(aStr);
|
|
fpSysLog->logMsg(errMsgArgs, logging::LOG_TYPE_INFO, logging::M0000);
|
|
|
|
exit(SPLTR_EXIT_STATUS); //BUG 4534 - exit w/o writing to log
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Process messages on Main thread
|
|
//------------------------------------------------------------------------------
|
|
void WESplitterApp::processMessages()
|
|
{
|
|
boost::uuids::uuid u=boost::uuids::random_generator()();
|
|
fCmdArgs.setJobUUID(u);
|
|
|
|
messageqcpp::ByteStream aBs;
|
|
unsigned int aRollCount = 0;
|
|
|
|
if(fDh.getDebugLvl())
|
|
cout << "Inside WESplitterApp::processMessages() "
|
|
<< "Mode = " << fCmdArgs.getMode() << endl;
|
|
|
|
//TODO - handle all the messages here
|
|
if (fCmdArgs.getMode() == 2)
|
|
{
|
|
try
|
|
{
|
|
aBs << (ByteStream::byte) WE_CLT_SRV_MODE;
|
|
aBs << (ByteStream::quadbyte) fCmdArgs.getMode();
|
|
fDh.send2Pm(aBs);
|
|
|
|
std::string aJobId = fCmdArgs.getJobId();
|
|
if((aJobId.length()>0)&&(!fCmdArgs.isJobLogOnly())) // Export jobFile NOW
|
|
{
|
|
std::string aJobFileName = fCmdArgs.getJobFileName();
|
|
fDh.exportJobFile(aJobId, aJobFileName );
|
|
}
|
|
|
|
aBs.restart();
|
|
std::string aCpImpCmd = fCmdArgs.getCpImportCmdLine();
|
|
fDh.fLog.logMsg( aCpImpCmd, MSGLVL_INFO2 );
|
|
if(fDh.getDebugLvl())
|
|
cout << "CPImport cmd line - " << aCpImpCmd << endl;
|
|
aBs << (ByteStream::byte) WE_CLT_SRV_CMDLINEARGS;
|
|
aBs << aCpImpCmd;
|
|
fDh.send2Pm(aBs);
|
|
|
|
aBs.restart();
|
|
std::string aBrmRpt = fCmdArgs.getBrmRptFileName();
|
|
if(fDh.getDebugLvl())
|
|
cout << "BrmReport FileName - " << aBrmRpt << endl;
|
|
aBs << (ByteStream::byte) WE_CLT_SRV_BRMRPT;
|
|
aBs << aBrmRpt;
|
|
fDh.send2Pm(aBs);
|
|
|
|
}
|
|
catch (std::exception& exp)
|
|
{
|
|
//cout << exp.what() << endl;
|
|
SPLTR_EXIT_STATUS=1;
|
|
//exit(SPLTR_EXIT_STATUS);
|
|
throw runtime_error(exp.what());
|
|
}
|
|
}
|
|
else if (fCmdArgs.getMode() == 1)
|
|
{
|
|
try
|
|
{
|
|
// In this mode we ignore almost all cmd lines args which
|
|
// are usually send to cpimport
|
|
aBs << (ByteStream::byte) WE_CLT_SRV_MODE;
|
|
aBs << (ByteStream::quadbyte) fCmdArgs.getMode();
|
|
fDh.send2Pm(aBs);
|
|
|
|
std::string aJobId = fCmdArgs.getJobId();
|
|
if(fDh.getDebugLvl()) cout<<"ProcessMsgs aJobId "<<aJobId<<endl;
|
|
if((aJobId.length()>0)&&(!fCmdArgs.isJobLogOnly())) // Export jobFile NOW
|
|
{
|
|
std::string aJobFileName = fCmdArgs.getJobFileName();
|
|
if(fDh.getDebugLvl()) cout<<"ProcessMsgs Calling exportJobFile "<<endl;
|
|
fDh.exportJobFile(aJobId, aJobFileName );
|
|
if(fDh.getDebugLvl()) cout<<"ProcessMsgs Calling exportJobFile "<<endl;
|
|
}
|
|
|
|
aBs.restart();
|
|
std::string aCpImpCmd = fCmdArgs.getCpImportCmdLine();
|
|
fDh.fLog.logMsg( aCpImpCmd, MSGLVL_INFO2 );
|
|
if(fDh.getDebugLvl())
|
|
cout << "CPImport cmd line - " << aCpImpCmd << endl;
|
|
aBs << (ByteStream::byte) WE_CLT_SRV_CMDLINEARGS;
|
|
aBs << aCpImpCmd;
|
|
fDh.send2Pm(aBs);
|
|
|
|
aBs.restart();
|
|
std::string aBrmRpt = fCmdArgs.getBrmRptFileName();
|
|
if(fDh.getDebugLvl())
|
|
cout << "BrmReport FileName - " << aBrmRpt << endl;
|
|
aBs << (ByteStream::byte) WE_CLT_SRV_BRMRPT;
|
|
aBs << aBrmRpt;
|
|
fDh.send2Pm(aBs);
|
|
|
|
} catch (std::exception& exp)
|
|
{
|
|
//cout << exp.what() << endl;
|
|
SPLTR_EXIT_STATUS=1;
|
|
//exit(SPLTR_EXIT_STATUS);
|
|
throw runtime_error(exp.what());
|
|
}
|
|
}
|
|
else if (fCmdArgs.getMode() == 0)
|
|
{
|
|
try
|
|
{
|
|
// In this mode we ignore almost all cmd lines args which
|
|
// are usually send to cpimport
|
|
aBs << (ByteStream::byte) WE_CLT_SRV_MODE;
|
|
aBs << (ByteStream::quadbyte) fCmdArgs.getMode();
|
|
fDh.send2Pm(aBs);
|
|
|
|
aBs.restart();
|
|
std::string aCpImpFileName = fCmdArgs.getPmFile();
|
|
if(aCpImpFileName.length()==0)
|
|
{
|
|
fCmdArgs.setPmFile(fCmdArgs.getLocFile());
|
|
aCpImpFileName = fCmdArgs.getPmFile();
|
|
if((aCpImpFileName.length()==0)||(aCpImpFileName == "STDIN"))
|
|
{
|
|
throw (runtime_error("PM Remote filename not specified"));
|
|
}
|
|
}
|
|
if(fDh.getDebugLvl())
|
|
cout << "CPImport FileName - " << aCpImpFileName << endl;
|
|
aBs << (ByteStream::byte) WE_CLT_SRV_IMPFILENAME;
|
|
aBs << aCpImpFileName;
|
|
fDh.send2Pm(aBs);
|
|
}
|
|
catch (std::exception& exp)
|
|
{
|
|
//cout << exp.what() << endl;
|
|
SPLTR_EXIT_STATUS=1;
|
|
//exit(SPLTR_EXIT_STATUS);
|
|
throw runtime_error(exp.what());
|
|
}
|
|
}
|
|
|
|
int aNoSec=2;
|
|
bool bRollback = false;
|
|
bool bForce = false;
|
|
int iShutdown;
|
|
// TODO - this is for just time being....
|
|
// we need to process message of main thread here..
|
|
// here we need to cont check the status of different things
|
|
while (fContinue)
|
|
{
|
|
++aRollCount;
|
|
usleep(1000000);
|
|
// Check to see if someone has ordered a shutdown with rollback or force.
|
|
iShutdown = fDh.fDbrm.getSystemShutdownPending(bRollback, bForce);
|
|
if (iShutdown >= 0)
|
|
{
|
|
if (bRollback)
|
|
{
|
|
if (iShutdown > 0) // Means a shutdown, stop or restart
|
|
{
|
|
cout << "System stop has been ordered. Rollback" << endl;
|
|
}
|
|
else
|
|
{
|
|
cout << "Database writes have been suspended. Rollback" << endl;
|
|
}
|
|
fSignaled = true;
|
|
fContinue = false;
|
|
}
|
|
else
|
|
if (bForce)
|
|
{
|
|
//BUG 5012 - added to avoid rollback
|
|
fContinue = false;
|
|
ostringstream oss;
|
|
oss << "Table "<<fCmdArgs.getSchemaName()<<".";
|
|
oss << fCmdArgs.getTableName() << ": (OID-";
|
|
oss << fDh.getTableOID() << ") was NOT successfully loaded.";
|
|
cout << oss.str() << endl;
|
|
logging::Message::Args errMsgArgs;
|
|
//BUG 4152
|
|
errMsgArgs.add(fCmdArgs.getSchemaName());
|
|
errMsgArgs.add(fCmdArgs.getTableName());
|
|
errMsgArgs.add(fDh.getTableOID());
|
|
std::string aStr = "Immediate system stop has been ordered, rollback deferred";
|
|
cout << aStr << endl;
|
|
SPLTR_EXIT_STATUS = 1;
|
|
errMsgArgs.add(aStr);
|
|
fpSysLog->logMsg(errMsgArgs, logging::LOG_TYPE_INFO, logging::M0096);
|
|
exit(SPLTR_EXIT_STATUS);
|
|
//BUG 5012 - commented out to avoid rollback
|
|
//cout << "Immediate system stop has been ordered. No rollback" << endl;
|
|
//fSignaled = true;
|
|
//fContinue = false;
|
|
}
|
|
}
|
|
|
|
// Send out a heartbeat to the WriteEnginServers every 10 seconds
|
|
if ((0 == (aRollCount % aNoSec)) && (!fSignaled)) // Debugging - every 10 seconds
|
|
{
|
|
if(aNoSec<10) aNoSec++; //progressively go up to 10Sec interval
|
|
aBs.restart();
|
|
aBs << (ByteStream::byte) WE_CLT_SRV_KEEPALIVE;
|
|
mutex::scoped_lock aLock(fDh.fSendMutex);
|
|
fDh.send2Pm(aBs);
|
|
aLock.unlock();
|
|
//fDh.sendHeartbeats();
|
|
//fDh.checkForConnections(); - decided to recv SIGHUP from OAM instead of this
|
|
}
|
|
}
|
|
|
|
fDh.shutdown();
|
|
|
|
} // processMessages
|
|
|
|
void WESplitterApp::invokeCpimport()
|
|
{
|
|
boost::uuids::uuid u=boost::uuids::random_generator()();
|
|
fCmdArgs.setJobUUID(u);
|
|
|
|
//BUG 4361 - check cpimport.bin is available or not
|
|
std::string aCpiBinFile = getCalpontHome() + "/cpimport.bin"; //BUG 4361
|
|
if (access(aCpiBinFile.c_str(), X_OK) != 0)
|
|
throw runtime_error("Error: Missing File " + aCpiBinFile);
|
|
|
|
fCmdArgs.setMode(3);
|
|
std::string aCmdLineStr = fCmdArgs.getCpImportCmdLine();
|
|
|
|
updateCmdLineWithPath(aCmdLineStr);
|
|
|
|
if(fDh.getDebugLvl())
|
|
cout << "CPI CmdLineArgs : " << aCmdLineStr << endl;
|
|
|
|
std::vector<char*> Cmds;
|
|
|
|
std::istringstream ss(aCmdLineStr);
|
|
std::string arg;
|
|
std::vector<std::string> v2(20, "");
|
|
unsigned int i = 0;
|
|
while(ss >> arg)
|
|
{
|
|
//we need something that works on Windows as well as linux
|
|
v2[i++] = arg;
|
|
}
|
|
for (unsigned int j = 0; j < i; ++j)
|
|
{
|
|
Cmds.push_back(const_cast<char*>(v2[j].c_str()));
|
|
}
|
|
|
|
Cmds.push_back(0); //null terminate
|
|
|
|
int aRet = execv(Cmds[0], &Cmds[0]); //NOTE - works with full Path
|
|
|
|
if(fDh.getDebugLvl())
|
|
cout << "Return status of cpimport is " << aRet <<endl;
|
|
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
/**
|
|
*
|
|
* @brief Include the absolute path to prgm name, which is
|
|
* @brief the first element in the vector
|
|
* @param V vector which contains each element of argv
|
|
*
|
|
**/
|
|
std::string WESplitterApp::getCalpontHome()
|
|
{
|
|
string calpontDir = config::Config::makeConfig()->getConfig(
|
|
"SystemConfig", "CalpontHome");
|
|
if(0 == calpontDir.length())
|
|
{
|
|
calpontDir = startup::StartUp::installDir() + "/bin";
|
|
}
|
|
else
|
|
{
|
|
calpontDir += "/bin";
|
|
}
|
|
|
|
return calpontDir;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
/**
|
|
*
|
|
* @brief Include the absolute path to prgm name, which is
|
|
* @brief the first element in the vector
|
|
* @param V vector which contains each element of argv
|
|
*
|
|
**/
|
|
std::string WESplitterApp::getPrgmPath(std::string& PrgmName)
|
|
{
|
|
std::string cpimportPath = getCalpontHome();
|
|
cpimportPath += "/";
|
|
cpimportPath += PrgmName;
|
|
return cpimportPath;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
/**
|
|
*
|
|
* @brief Include the absolute path to prgm name, which is
|
|
* @brief the first element in the vector
|
|
* @param V vector which contains each element of argv
|
|
*
|
|
**/
|
|
|
|
void WESplitterApp::updateCmdLineWithPath(string& CmdLine)
|
|
{
|
|
std::istringstream iSs(CmdLine);
|
|
std::ostringstream oSs;
|
|
std::string aArg;
|
|
int aCount=0;
|
|
while(iSs >> aArg)
|
|
{
|
|
if(0 == aCount)
|
|
{
|
|
string aPrgmPath = getPrgmPath(aArg);
|
|
oSs << aPrgmPath;
|
|
}
|
|
else
|
|
{
|
|
oSs << " ";
|
|
oSs << aArg;
|
|
|
|
}
|
|
++aCount;
|
|
}
|
|
|
|
CmdLine = oSs.str();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
void WESplitterApp::updateWithJobFile(int aIdx)
|
|
{
|
|
fCmdArgs.updateWithJobFile(aIdx);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
|
|
} /* namespace WriteEngine */
|
|
|
|
//------------------------------------------------------------------------------
|
|
// main function
|
|
//------------------------------------------------------------------------------
|
|
|
|
int main(int argc, char** argv)
|
|
{
|
|
std::string err;
|
|
setuid(0); //@BUG 4343 set effective userid to root.
|
|
std::cin.sync_with_stdio(false);
|
|
try
|
|
{
|
|
WriteEngine::WECmdArgs aWeCmdArgs(argc, argv);
|
|
WriteEngine::WESplitterApp aWESplitterApp(aWeCmdArgs);
|
|
int aTblCnt = aWESplitterApp.fCmdArgs.getMultiTableCount();
|
|
if(aTblCnt>1)
|
|
{
|
|
for(int idx=0; idx<aTblCnt; idx++)
|
|
{
|
|
aWESplitterApp.fDh.reset();
|
|
aWESplitterApp.fContinue = true;
|
|
aWESplitterApp.updateWithJobFile(idx);
|
|
try
|
|
{
|
|
aWESplitterApp.fDh.setup();
|
|
}
|
|
catch (std::exception& ex)
|
|
{
|
|
//err = string("Error in constructing WESplitterApp") + ex.what();
|
|
err = ex.what(); //cleaning up for BUG 4298
|
|
logging::Message::Args errMsgArgs;
|
|
errMsgArgs.add(err);
|
|
aWESplitterApp.fpSysLog->logMsg(errMsgArgs,logging::LOG_TYPE_ERROR,logging::M0000);
|
|
SPLTR_EXIT_STATUS=1;
|
|
aWESplitterApp.fDh.fLog.logMsg( err, MSGLVL_ERROR );
|
|
aWESplitterApp.fContinue = false;
|
|
//throw runtime_error(err); BUG 4298
|
|
}
|
|
aWESplitterApp.processMessages();
|
|
|
|
if(SPLTR_EXIT_STATUS == 1) break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
aWESplitterApp.processMessages();
|
|
}
|
|
} catch (std::exception& exp)
|
|
{
|
|
cerr << exp.what() << endl;
|
|
SPLTR_EXIT_STATUS = 1;
|
|
exit(SPLTR_EXIT_STATUS); // exit with an error
|
|
}
|
|
|
|
return SPLTR_EXIT_STATUS;
|
|
}
|
|
// vim:ts=4 sw=4:
|
|
|