void
handler_error(int signum){
// only let one thread run shutdown
static bool handling_error = false;
static pthread_t thread_id; // Valid when handling_error is true
if (handling_error &&
pthread_equal(thread_id, pthread_self()))
{
// Shutdown thread received signal
#ifndef NDB_WIN32
signal(signum, SIG_DFL);
kill(getpid(), signum);
#endif
while(true)
NdbSleep_MilliSleep(10);
}
if(theShutdownMutex && NdbMutex_Trylock(theShutdownMutex) != 0)
while(true)
NdbSleep_MilliSleep(10);
thread_id = pthread_self();
handling_error = true;
g_eventLogger->info("Received signal %d. Running error handler.", signum);
childReportSignal(signum);
// restart the system
char errorData[64], *info= 0;
#ifdef HAVE_STRSIGNAL
info= strsignal(signum);
#endif
BaseString::snprintf(errorData, sizeof(errorData), "Signal %d received; %s", signum,
info ? info : "No text for signal available");
ERROR_SET_SIGNAL(fatal, NDBD_EXIT_OS_SIGNAL_RECEIVED, errorData, __FILE__);
}
extern "C" void* NdbThreadFuncUpdate(void* pArg)
{
myRandom48Init((long int)NdbTick_CurrentMillisecond());
unsigned nSucc = 0;
unsigned nFail = 0;
Ndb* pNdb = NULL ;
pNdb = new Ndb("TEST_DB");
VerifyMethodInt(pNdb, init());
VerifyMethodInt(pNdb, waitUntilReady());
while(NdbMutex_Trylock(g_pNdbMutex)) {
Uint32 nWarehouse = myRandom48(g_nWarehouseCount);
NdbConnection* pNdbConnection = NULL ;
VerifyMethodPtr(pNdbConnection, pNdb, startTransaction());
CHK_TR(pNdbConnection) ; // epaulsa
NdbOperation* pNdbOperationW = NULL ;
VerifyMethodPtr(pNdbOperationW, pNdbConnection, getNdbOperation(c_szWarehouse));
VerifyMethodInt(pNdbOperationW, interpretedUpdateTuple());
VerifyMethodInt(pNdbOperationW, equal(c_szWarehouseNumber, nWarehouse));
VerifyMethodInt(pNdbOperationW, incValue(c_szWarehouseCount, Uint32(1)));
Uint32 nWarehouseSum = 0;
for(Uint32 nDistrict=0; nDistrict<g_nDistrictPerWarehouse; ++nDistrict) {
NdbOperation* pNdbOperationD = NULL ;
VerifyMethodPtr(pNdbOperationD, pNdbConnection, getNdbOperation(c_szDistrict));
VerifyMethodInt(pNdbOperationD, interpretedUpdateTuple());
VerifyMethodInt(pNdbOperationD, equal(c_szDistrictWarehouseNumber, nWarehouse));
VerifyMethodInt(pNdbOperationD, equal(c_szDistrictNumber, nDistrict));
VerifyMethodInt(pNdbOperationD, incValue(c_szDistrictCount, Uint32(1)));
Uint32 nDistrictSum = myRandom48(100);
nWarehouseSum += nDistrictSum;
VerifyMethodInt(pNdbOperationD, setValue(c_szDistrictSum, nDistrictSum));
}
VerifyMethodInt(pNdbOperationW, setValue(c_szWarehouseSum, nWarehouseSum));
int iExec = pNdbConnection->execute(Commit);
int iError = pNdbConnection->getNdbError().code;
if(iExec<0 && iError!=0 && iError!=266 && iError!=626) {
ReportMethodInt(iExec, pNdbConnection, "pNdbConnection", "execute(Commit)", __FILE__, __LINE__);
}
if(iExec==0) {
++nSucc;
} else {
++nFail;
}
VerifyMethodVoid(pNdb, closeTransaction(pNdbConnection));
}
ndbout << "update: " << nSucc << " succeeded, " << nFail << " failed " << endl;
NdbMutex_Unlock(g_pNdbMutex);
delete pNdb;
pNdb = NULL ;
return NULL;
}
void
NdbShutdown(int error_code,
NdbShutdownType type,
NdbRestartType restartType)
{
if(type == NST_ErrorInsert)
{
type = NST_Restart;
restartType = (NdbRestartType)
globalEmulatorData.theConfiguration->getRestartOnErrorInsert();
if(restartType == NRT_Default)
{
type = NST_ErrorHandler;
globalEmulatorData.theConfiguration->stopOnError(true);
}
}
if((type == NST_ErrorHandlerSignal) || // Signal handler has already locked mutex
(NdbMutex_Trylock(theShutdownMutex) == 0)){
globalData.theRestartFlag = perform_stop;
bool restart = false;
if((type != NST_Normal &&
globalEmulatorData.theConfiguration->stopOnError() == false) ||
type == NST_Restart)
{
restart = true;
}
const char * shutting = "shutting down";
if(restart)
{
shutting = "restarting";
}
switch(type){
case NST_Normal:
g_eventLogger->info("Shutdown initiated");
break;
case NST_Watchdog:
g_eventLogger->info("Watchdog %s system", shutting);
break;
case NST_ErrorHandler:
g_eventLogger->info("Error handler %s system", shutting);
break;
case NST_ErrorHandlerSignal:
g_eventLogger->info("Error handler signal %s system", shutting);
break;
case NST_Restart:
g_eventLogger->info("Restarting system");
break;
default:
g_eventLogger->info("Error handler %s system (unknown type: %u)",
shutting, (unsigned)type);
type = NST_ErrorHandler;
break;
}
const char * exitAbort = 0;
if (opt_core)
exitAbort = "aborting";
else
exitAbort = "exiting";
if(type == NST_Watchdog)
{
/**
* Very serious, don't attempt to free, just die!!
*/
g_eventLogger->info("Watchdog shutdown completed - %s", exitAbort);
if (opt_core)
{
childAbort(error_code, -1,g_currentStartPhase);
}
else
{
childExit(error_code, -1,g_currentStartPhase);
}
}
#ifndef NDB_WIN32
if (simulate_error_during_shutdown)
{
kill(getpid(), simulate_error_during_shutdown);
while(true)
NdbSleep_MilliSleep(10);
}
#endif
globalEmulatorData.theWatchDog->doStop();
#ifdef VM_TRACE
FILE * outputStream = globalSignalLoggers.setOutputStream(0);
if(outputStream != 0)
fclose(outputStream);
#endif
/**
* Don't touch transporter here (yet)
* cause with ndbmtd, there are locks and nasty stuff
* and we don't know which we are holding...
*/
#if NOT_YET
/**
* Stop all transporter connection attempts and accepts
*/
globalEmulatorData.m_socket_server->stopServer();
globalEmulatorData.m_socket_server->stopSessions();
globalTransporterRegistry.stop_clients();
/**
* Stop transporter communication with other nodes
*/
globalTransporterRegistry.stopSending();
globalTransporterRegistry.stopReceiving();
/**
* Remove all transporters
*/
globalTransporterRegistry.removeAll();
#endif
if(type == NST_ErrorInsert && opt_core)
{
// Unload some structures to reduce size of core
globalEmulatorData.theSimBlockList->unload();
NdbMutex_Unlock(theShutdownMutex);
globalEmulatorData.destroy();
}
if(type != NST_Normal && type != NST_Restart)
{
g_eventLogger->info("Error handler shutdown completed - %s", exitAbort);
if (opt_core)
{
childAbort(error_code, -1,g_currentStartPhase);
}
else
{
childExit(error_code, -1,g_currentStartPhase);
}
}
/**
* This is a normal restart, depend on angel
*/
if(type == NST_Restart){
childExit(error_code, restartType,g_currentStartPhase);
}
g_eventLogger->info("Shutdown completed - exiting");
}
else
{
/**
* Shutdown is already in progress
*/
/**
* If this is the watchdog, kill system the hard way
*/
if (type== NST_Watchdog)
{
g_eventLogger->info("Watchdog is killing system the hard way");
#if defined VM_TRACE
childAbort(error_code, -1,g_currentStartPhase);
#else
childExit(error_code, -1, g_currentStartPhase);
#endif
}
while(true)
NdbSleep_MilliSleep(10);
}
}
extern "C" void* NdbThreadFuncRead(void* pArg)
{
myRandom48Init((long int)NdbTick_CurrentMillisecond());
unsigned nSucc = 0;
unsigned nFail = 0;
NdbRecAttr** ppNdbRecAttrDSum = new NdbRecAttr*[g_nDistrictPerWarehouse];
NdbRecAttr** ppNdbRecAttrDCnt = new NdbRecAttr*[g_nDistrictPerWarehouse];
Ndb* pNdb = NULL ;
pNdb = new Ndb("TEST_DB");
VerifyMethodInt(pNdb, init());
VerifyMethodInt(pNdb, waitUntilReady());
while(NdbMutex_Trylock(g_pNdbMutex)) {
Uint32 nWarehouse = myRandom48(g_nWarehouseCount);
NdbConnection* pNdbConnection = NULL ;
VerifyMethodPtr(pNdbConnection, pNdb, startTransaction());
CHK_TR(pNdbConnection) ; // epaulsa
NdbOperation* pNdbOperationW = NULL ;
VerifyMethodPtr(pNdbOperationW, pNdbConnection, getNdbOperation(c_szWarehouse));
VerifyMethodInt(pNdbOperationW, readTuple());
VerifyMethodInt(pNdbOperationW, equal(c_szWarehouseNumber, nWarehouse));
NdbRecAttr* pNdbRecAttrWSum;
VerifyMethodPtr(pNdbRecAttrWSum, pNdbOperationW, getValue(c_szWarehouseSum, 0));
NdbRecAttr* pNdbRecAttrWCnt;
VerifyMethodPtr(pNdbRecAttrWCnt, pNdbOperationW, getValue(c_szWarehouseCount, 0));
for(Uint32 nDistrict=0; nDistrict<g_nDistrictPerWarehouse; ++nDistrict) {
NdbOperation* pNdbOperationD = NULL ;
VerifyMethodPtr(pNdbOperationD, pNdbConnection, getNdbOperation(c_szDistrict));
VerifyMethodInt(pNdbOperationD, readTuple());
VerifyMethodInt(pNdbOperationD, equal(c_szDistrictWarehouseNumber, nWarehouse));
VerifyMethodInt(pNdbOperationD, equal(c_szDistrictNumber, nDistrict));
VerifyMethodPtr(ppNdbRecAttrDSum[nDistrict], pNdbOperationD, getValue(c_szDistrictSum, 0));
VerifyMethodPtr(ppNdbRecAttrDCnt[nDistrict], pNdbOperationD, getValue(c_szDistrictCount, 0));
}
int iExec = pNdbConnection->execute(Commit);
int iError = pNdbConnection->getNdbError().code;
if(iExec<0 && iError!=0 && iError!=266 && iError!=626) {
ReportMethodInt(iExec, pNdbConnection, "pNdbConnection", "execute(Commit)", __FILE__, __LINE__);
}
if(iExec==0) {
Uint32 nSum = 0;
Uint32 nCnt = 0;
for(Uint32 nDistrict=0; nDistrict<g_nDistrictPerWarehouse; ++nDistrict) {
nSum += ppNdbRecAttrDSum[nDistrict]->u_32_value();
nCnt += ppNdbRecAttrDCnt[nDistrict]->u_32_value();
}
if(nSum!=pNdbRecAttrWSum->u_32_value()
|| nCnt!=g_nDistrictPerWarehouse*pNdbRecAttrWCnt->u_32_value()) {
ndbout << "INCONSISTENT!" << endl;
ndbout << "iExec==" << iExec << endl;
ndbout << "iError==" << iError << endl;
ndbout << endl;
ndbout << c_szWarehouseSum << "==" << pNdbRecAttrWSum->u_32_value() << ", ";
ndbout << c_szWarehouseCount << "==" << pNdbRecAttrWCnt->u_32_value() << endl;
ndbout << "nSum==" << nSum << ", nCnt=" << nCnt << endl;
for(Uint32 nDistrict=0; nDistrict<g_nDistrictPerWarehouse; ++nDistrict) {
ndbout << c_szDistrictSum << "[" << nDistrict << "]==" << ppNdbRecAttrDSum[nDistrict]->u_32_value() << ", ";
ndbout << c_szDistrictCount << "[" << nDistrict << "]==" << ppNdbRecAttrDCnt[nDistrict]->u_32_value() << endl;
}
VerifyMethodVoid(pNdb, closeTransaction(pNdbConnection));
delete pNdb;
pNdb = NULL ;
delete[] ppNdbRecAttrDSum;
ppNdbRecAttrDSum = NULL ;
delete[] ppNdbRecAttrDCnt;
ppNdbRecAttrDCnt = NULL ;
NDBT_ProgramExit(NDBT_FAILED);
}
++nSucc;
} else {
++nFail;
}
VerifyMethodVoid(pNdb, closeTransaction(pNdbConnection));
}
ndbout << "read: " << nSucc << " succeeded, " << nFail << " failed " << endl;
NdbMutex_Unlock(g_pNdbMutex);
delete pNdb;
pNdb = NULL ;
delete[] ppNdbRecAttrDSum;
ppNdbRecAttrDSum = NULL ;
delete[] ppNdbRecAttrDCnt;
ppNdbRecAttrDCnt = NULL ;
return NULL;
}