/******************************************************************************
* Arbitrator
******************************************************************************/
ArbitMgr::ArbitMgr(ClusterMgr & c)
: m_clusterMgr(c)
{
DBUG_ENTER("ArbitMgr::ArbitMgr");
theThreadMutex = NdbMutex_Create();
theInputCond = NdbCondition_Create();
theInputMutex = NdbMutex_Create();
theRank = 0;
theDelay = 0;
theThread = 0;
theInputTimeout = 0;
theInputFull = false;
memset(&theInputBuffer, 0, sizeof(theInputBuffer));
theState = StateInit;
memset(&theStartReq, 0, sizeof(theStartReq));
memset(&theChooseReq1, 0, sizeof(theChooseReq1));
memset(&theChooseReq2, 0, sizeof(theChooseReq2));
memset(&theStopOrd, 0, sizeof(theStopOrd));
DBUG_VOID_RETURN;
}
/******************************************************************************
* Arbitrator
******************************************************************************/
ArbitMgr::ArbitMgr(TransporterFacade & _fac)
: theFacade(_fac)
{
DBUG_ENTER("ArbitMgr::ArbitMgr");
theThreadMutex = NdbMutex_Create();
theInputCond = NdbCondition_Create();
theInputMutex = NdbMutex_Create();
theRank = 0;
theDelay = 0;
theThread = 0;
theInputTimeout = 0;
theInputFull = false;
memset(&theInputFull, 0, sizeof(theInputFull));
theState = StateInit;
memset(&theStartReq, 0, sizeof(theStartReq));
memset(&theChooseReq1, 0, sizeof(theChooseReq1));
memset(&theChooseReq2, 0, sizeof(theChooseReq2));
memset(&theStopOrd, 0, sizeof(theStopOrd));
DBUG_VOID_RETURN;
}
Logger::Logger() :
m_pCategory("Logger"),
m_pConsoleHandler(NULL),
m_pFileHandler(NULL),
m_pSyslogHandler(NULL)
{
m_pHandlerList = new LogHandlerList();
m_mutex= NdbMutex_Create();
m_handler_mutex= NdbMutex_Create();
disable(LL_ALL);
enable(LL_ON);
enable(LL_INFO);
}
void
AsyncFile::doStart(Uint32 nodeId,
const char * filesystemPath,
const char * backup_path) {
theFileName.init(nodeId, filesystemPath, backup_path);
// Stacksize for filesystem threads
// An 8k stack should be enough
const NDB_THREAD_STACKSIZE stackSize = 8192;
char buf[16];
numAsyncFiles++;
BaseString::snprintf(buf, sizeof(buf), "AsyncFile%d", numAsyncFiles);
theStartMutexPtr = NdbMutex_Create();
theStartConditionPtr = NdbCondition_Create();
NdbMutex_Lock(theStartMutexPtr);
theStartFlag = false;
theThreadPtr = NdbThread_Create(runAsyncFile,
(void**)this,
stackSize,
(char*)&buf,
NDB_THREAD_PRIO_MEAN);
NdbCondition_Wait(theStartConditionPtr,
theStartMutexPtr);
NdbMutex_Unlock(theStartMutexPtr);
NdbMutex_Destroy(theStartMutexPtr);
NdbCondition_Destroy(theStartConditionPtr);
}
ClusterMgr::ClusterMgr(TransporterFacade & _facade):
theStop(0),
m_sent_API_REGREQ_to_myself(false),
theFacade(_facade),
theArbitMgr(NULL),
m_connect_count(0),
m_max_api_reg_req_interval(~0),
noOfAliveNodes(0),
noOfConnectedNodes(0),
noOfConnectedDBNodes(0),
minDbVersion(0),
theClusterMgrThread(NULL),
m_cluster_state(CS_waiting_for_clean_cache),
m_hbFrequency(0)
{
DBUG_ENTER("ClusterMgr::ClusterMgr");
clusterMgrThreadMutex = NdbMutex_Create();
waitForHBCond= NdbCondition_Create();
m_auto_reconnect = -1;
Uint32 ret = this->open(&theFacade, API_CLUSTERMGR);
if (unlikely(ret == 0))
{
ndbout_c("Failed to register ClusterMgr! ret: %d", ret);
abort();
}
DBUG_VOID_RETURN;
}
void
ndb_init_internal()
{
NdbOut_Init();
if (!g_ndb_connection_mutex)
g_ndb_connection_mutex = NdbMutex_Create();
if (!g_eventLogger)
g_eventLogger = create_event_logger();
if ((g_ndb_connection_mutex == NULL) || (g_eventLogger == NULL))
{
{
const char* err = "ndb_init() failed - exit\n";
int res = write(2, err, strlen(err));
(void)res;
exit(1);
}
}
/* Always turn on monotonic unless on Solaris */
#ifndef __sun
g_ndb_init_need_monotonic = 1;
#endif
NdbTick_Init(g_ndb_init_need_monotonic);
NdbCondition_initialize(g_ndb_init_need_monotonic);
NdbThread_Init();
}
void
AsyncFile::doStart()
{
// Stacksize for filesystem threads
#if !defined(DBUG_OFF) && defined (__hpux)
// Empirical evidence indicates at least 32k
const NDB_THREAD_STACKSIZE stackSize = 32768;
#else
// Otherwise an 8k stack should be enough
const NDB_THREAD_STACKSIZE stackSize = 8192;
#endif
char buf[16];
numAsyncFiles++;
BaseString::snprintf(buf, sizeof(buf), "AsyncFile%d", numAsyncFiles);
theStartMutexPtr = NdbMutex_Create();
theStartConditionPtr = NdbCondition_Create();
NdbMutex_Lock(theStartMutexPtr);
theStartFlag = false;
theThreadPtr = NdbThread_Create(runAsyncFile,
(void**)this,
stackSize,
(char*)&buf,
NDB_THREAD_PRIO_MEAN);
if (theThreadPtr == 0)
ERROR_SET(fatal, NDBD_EXIT_MEMALLOC, "","Could not allocate file system thread");
NdbCondition_Wait(theStartConditionPtr,
theStartMutexPtr);
NdbMutex_Unlock(theStartMutexPtr);
NdbMutex_Destroy(theStartMutexPtr);
NdbCondition_Destroy(theStartConditionPtr);
}
void
NDBT_Thread::create(NDBT_ThreadSet* thread_set, int thread_no)
{
m_magic = NDBT_Thread::Magic;
m_state = Wait;
m_thread_set = thread_set;
m_thread_no = thread_no;
m_func = 0;
m_input = 0;
m_output = 0;
m_ndb = 0;
m_err = 0;
m_mutex = NdbMutex_Create();
assert(m_mutex != 0);
m_cond = NdbCondition_Create();
assert(m_cond != 0);
char buf[20];
sprintf(buf, "NDBT_%04u");
const char* name = strdup(buf);
assert(name != 0);
unsigned stacksize = 512 * 1024;
NDB_THREAD_PRIO prio = NDB_THREAD_PRIO_LOW;
m_thread = NdbThread_Create(NDBT_Thread_run,
(void**)this, stacksize, name, prio);
assert(m_thread != 0);
}
WatchDog::WatchDog(Uint32 interval) :
m_watchedCount(0)
{
setCheckInterval(interval);
m_mutex = NdbMutex_Create();
theStop = false;
theThreadPtr = 0;
}
void VerifyBegin(void)
{
if(!g_pNdbMutexVerify)
{
g_pNdbMutexVerify = NdbMutex_Create();
}
NdbMutex_Lock(g_pNdbMutexVerify);
}
void TraceBegin(void)
{
if(!g_pNdbMutexTrace)
{
g_pNdbMutexTrace = NdbMutex_Create();
}
NdbMutex_Lock(g_pNdbMutexTrace);
g_nParamTrace = 0;
}
Ndb_cluster_connection_impl::Ndb_cluster_connection_impl(const char *
connect_string)
: Ndb_cluster_connection(*this),
m_optimized_node_selection(1),
m_name(0)
{
DBUG_ENTER("Ndb_cluster_connection");
DBUG_PRINT("enter",("Ndb_cluster_connection this=0x%lx", (long) this));
g_eventLogger.createConsoleHandler();
g_eventLogger.setCategory("NdbApi");
g_eventLogger.enable(Logger::LL_ON, Logger::LL_ERROR);
m_connect_thread= 0;
m_connect_callback= 0;
if (ndb_global_event_buffer_mutex == NULL)
ndb_global_event_buffer_mutex= NdbMutex_Create();
#ifdef VM_TRACE
if (ndb_print_state_mutex == NULL)
ndb_print_state_mutex= NdbMutex_Create();
#endif
m_config_retriever=
new ConfigRetriever(connect_string, NDB_VERSION, NODE_TYPE_API);
if (m_config_retriever->hasError())
{
printf("Could not connect initialize handle to management server: %s",
m_config_retriever->getErrorString());
delete m_config_retriever;
m_config_retriever= 0;
}
if (m_name)
{
NdbMgmHandle h= m_config_retriever->get_mgmHandle();
ndb_mgm_set_name(h, m_name);
}
m_transporter_facade=
TransporterFacade::theFacadeInstance=
new TransporterFacade();
DBUG_VOID_RETURN;
}
bool
NdbPool::initPoolMutex()
{
bool ret_result = false;
if (pool_mutex == NULL) {
pool_mutex = NdbMutex_Create();
ret_result = ((pool_mutex == NULL) ? false : true);
}
return ret_result;
}
NDBT_TestCaseImpl1::NDBT_TestCaseImpl1(NDBT_TestSuite* psuite,
const char* pname,
const char* pcomment) :
NDBT_TestCase(psuite, pname, pcomment){
numStepsOk = 0;
numStepsFail = 0;
numStepsCompleted = 0;
waitThreadsMutexPtr = NdbMutex_Create();
waitThreadsCondPtr = NdbCondition_Create();
}
CPCD::Monitor::Monitor(CPCD *cpcd, int poll) {
m_cpcd = cpcd;
m_pollingInterval = poll;
m_changeCondition = NdbCondition_Create();
m_changeMutex = NdbMutex_Create();
m_monitorThread = NdbThread_Create(monitor_thread_create_wrapper,
(NDB_THREAD_ARG*) this,
0, // default stack size
"ndb_cpcd_monitor",
NDB_THREAD_PRIO_MEAN);
m_monitorThreadQuitFlag = false;
}
NDBT_Context::NDBT_Context(Ndb_cluster_connection& con)
: m_cluster_connection(con)
{
suite = NULL;
testcase = NULL;
ndb = NULL;
records = 1;
loops = 1;
stopped = false;
remote_mgm ="";
propertyMutexPtr = NdbMutex_Create();
propertyCondPtr = NdbCondition_Create();
}
MultiNdbWakeupHandler::MultiNdbWakeupHandler(Ndb* _wakeNdb)
: wakeNdb(_wakeNdb)
{
localWakeupMutexPtr = NdbMutex_Create();
assert(localWakeupMutexPtr);
/* Register the waiter Ndb to receive wakeups for all Ndbs in the group */
PollGuard pg(* wakeNdb->theImpl);
woken = false;
ignore_wakeups();
bool rc = wakeNdb->theImpl->m_transporter_facade->registerForWakeup(wakeNdb->theImpl);
require(rc);
wakeNdb->theImpl->wakeHandler = this;
}
NDBT_Context::NDBT_Context(Ndb_cluster_connection& con)
: m_cluster_connection(con)
{
suite = NULL;
testcase = NULL;
ndb = NULL;
records = 1;
loops = 1;
stopped = false;
propertyMutexPtr = NdbMutex_Create();
propertyCondPtr = NdbCondition_Create();
m_env_timeout = 0;
m_test_start_time = NdbTick_CurrentMillisecond();
}
MgmApiSession::MgmApiSession(class MgmtSrvr & mgm, NDB_SOCKET_TYPE sock, Uint64 session_id)
: SocketServer::Session(sock), m_mgmsrv(mgm)
{
DBUG_ENTER("MgmApiSession::MgmApiSession");
m_input = new SocketInputStream(sock, 30000);
m_output = new SocketOutputStream(sock, 30000);
m_parser = new Parser_t(commands, *m_input, true, true, true);
m_allocated_resources= new MgmtSrvr::Allocated_resources(m_mgmsrv);
m_stopSelf= 0;
m_ctx= NULL;
m_session_id= session_id;
m_mutex= NdbMutex_Create();
m_errorInsert= 0;
DBUG_VOID_RETURN;
}
ClusterMgr::ClusterMgr(TransporterFacade & _facade):
theStop(0),
theFacade(_facade)
{
DBUG_ENTER("ClusterMgr::ClusterMgr");
ndbSetOwnVersion();
clusterMgrThreadMutex = NdbMutex_Create();
waitForHBCond= NdbCondition_Create();
waitingForHB= false;
m_max_api_reg_req_interval= 0xFFFFFFFF; // MAX_INT
noOfAliveNodes= 0;
noOfConnectedNodes= 0;
theClusterMgrThread= 0;
m_connect_count = 0;
m_cluster_state = CS_waiting_for_clean_cache;
DBUG_VOID_RETURN;
}
struct NdbCondition*
NdbCondition_Create(void)
{
int result = 0;
struct NdbCondition* pNdbCondition = (struct NdbCondition*)malloc(sizeof(struct NdbCondition));
if(!pNdbCondition)
return 0;
pNdbCondition->nWaiters = 0;
pNdbCondition->bWasBroadcast = 0;
if(!(pNdbCondition->hSemaphore = CreateSemaphore(0, 0, MAXLONG, 0)))
result = -1;
else if(!(pNdbCondition->pNdbMutexWaitersLock = NdbMutex_Create()))
result = -1;
else if(!(pNdbCondition->hEventWaitersDone = CreateEvent(0, 0, 0, 0)))
result = -1;
assert(!result);
return pNdbCondition;
}
struct NdbThread*
AsyncIoThread::doStart()
{
// Stacksize for filesystem threads
const NDB_THREAD_STACKSIZE stackSize = 128*1024;
char buf[16];
numAsyncFiles++;
BaseString::snprintf(buf, sizeof(buf), "AsyncIoThread%d", numAsyncFiles);
theStartMutexPtr = NdbMutex_Create();
theStartConditionPtr = NdbCondition_Create();
NdbMutex_Lock(theStartMutexPtr);
theStartFlag = false;
theThreadPtr = NdbThread_Create(runAsyncIoThread,
(void**)this,
stackSize,
buf,
NDB_THREAD_PRIO_MEAN);
if (theThreadPtr == 0)
{
ERROR_SET(fatal, NDBD_EXIT_MEMALLOC,
"","Could not allocate file system thread");
}
do
{
NdbCondition_Wait(theStartConditionPtr,
theStartMutexPtr);
}
while (theStartFlag == false);
NdbMutex_Unlock(theStartMutexPtr);
NdbMutex_Destroy(theStartMutexPtr);
NdbCondition_Destroy(theStartConditionPtr);
return theThreadPtr;
}
void
EmulatorData::create(){
/*
Global jam() buffer, for non-multithreaded operation.
For multithreaded ndbd, each thread will set a local jam buffer later.
*/
#ifndef NO_EMULATED_JAM
void * jamBuffer = (void *)&theEmulatedJamBuffer;
#else
void * jamBuffer = 0;
#endif
NdbThread_SetTlsKey(NDB_THREAD_TLS_JAM, jamBuffer);
NdbMem_Create();
theConfiguration = new Configuration();
theWatchDog = new WatchDog();
theThreadConfig = new ThreadConfig();
theSimBlockList = new SimBlockList();
m_socket_server = new SocketServer();
m_mem_manager = new Ndbd_mem_manager();
globalData.m_global_page_pool.setMutex();
if (theConfiguration == NULL ||
theWatchDog == NULL ||
theThreadConfig == NULL ||
theSimBlockList == NULL ||
m_socket_server == NULL ||
m_mem_manager == NULL )
{
ERROR_SET(fatal, NDBD_EXIT_MEMALLOC,
"Failed to create EmulatorData", "");
}
if (!(theShutdownMutex = NdbMutex_Create()))
{
ERROR_SET(fatal, NDBD_EXIT_MEMALLOC,
"Failed to create shutdown mutex", "");
}
}
void init() {
mutex = NdbMutex_Create();
cond = NdbCondition_Create();
}
SignalQueue::SignalQueue() {
m_mutex = NdbMutex_Create();
m_cond = NdbCondition_Create();
m_signalQueueHead = NULL;
}
int main(int argc, char* argv[])
{
ndb_init();
int iRes = -1;
g_nNumThreads = 0;
g_nMaxCallsPerSecond = 0;
long nSeed = 0;
bool bStoredTable = true;
bool bCreateTable = false;
g_bWriteTuple = false;
g_bReport = false;
g_bReportPlus = false;
for(int i=1; i<argc; ++i)
{
if(argv[i][0]=='-' || argv[i][0]=='/')
{
switch(argv[i][1])
{
case 't':
g_nNumThreads = atol(argv[i]+2);
break;
case 's':
nSeed = atol(argv[i]+2);
break;
case 'b':
g_nMaxContextIdPerThread = atol(argv[i]+2);
break;
case 'm':
g_nStatusDataSize = atol(argv[i]+2);
if(g_nStatusDataSize>sizeof(STATUS_DATA))
{
g_nStatusDataSize = sizeof(STATUS_DATA);
}
break;
case 'i':
g_bInsertInitial = true;
break;
case 'v':
g_bVerifyInitial = true;
break;
case 'd':
bCreateTable = true;
break;
case 'f':
bStoredTable = false;
break;
case 'w':
g_bWriteTuple = true;
break;
case 'r':
g_bReport = true;
if(argv[i][2]=='+')
{
g_bReportPlus = true;
}
break;
case 'c':
g_nMaxCallsPerSecond = atol(argv[i]+2);
break;
case '?':
default:
ShowHelp(argv[0]);
return -1;
}
}
else
{
ShowHelp(argv[0]);
return -1;
}
}
if(bCreateTable)
puts("-d\tcreate the table");
if(g_bInsertInitial)
printf("-i\tinsert initial records\n");
if(g_bVerifyInitial)
printf("-v\tverify initial records\n");
if(g_nNumThreads>0)
printf("-t%ld\tnumber of threads making calls\n", g_nNumThreads);
if(g_nNumThreads>0)
{
printf("-s%ld\toffset for primary key\n", nSeed);
printf("-b%ld\tbatch size per thread\n", g_nMaxContextIdPerThread);
}
if(g_nMaxCallsPerSecond>0)
printf("-c%ld\tmax number of calls per second for this process\n", g_nMaxCallsPerSecond);
if(!bStoredTable)
puts("-f\tno checkpointing and no logging to disk");
if(g_bWriteTuple)
puts("-w\tuse writeTuple instead of insertTuple");
if(g_bReport)
puts("-r\treport response time statistics");
if(g_bReportPlus)
puts("-r+\treport response time distribution");
if(!bCreateTable && g_nNumThreads<=0)
{
ShowHelp(argv[0]);
return -1;
}
printf("-m%ld\tsize of context data\n", g_nStatusDataSize);
g_szTableName = (bStoredTable ? c_szTableNameStored : c_szTableNameTemp);
#ifdef NDB_WIN32
SetConsoleCtrlHandler(ConsoleCtrlHandler, true);
#else
signal(SIGINT, CtrlCHandler);
#endif
if(g_bReport)
{
g_plCountMillisecForCall = new long[c_nMaxMillisecForAllCall];
memset(g_plCountMillisecForCall, 0, c_nMaxMillisecForAllCall*sizeof(long));
g_plCountMillisecForTrans = new long[c_nMaxMillisecForAllTrans];
memset(g_plCountMillisecForTrans, 0, c_nMaxMillisecForAllTrans*sizeof(long));
}
g_pNdbMutexIncrement = NdbMutex_Create();
g_pNdbMutexPrintf = NdbMutex_Create();
#ifdef NDB_WIN32
hShutdownEvent = CreateEvent(NULL,TRUE,FALSE,NULL);
#endif
Ndb* pNdb = new Ndb(c_szDatabaseName);
if(!pNdb)
{
printf("could not construct ndb\n");
return 1;
}
if(pNdb->init(1) || pNdb->waitUntilReady())
{
ReportNdbError("could not initialize ndb\n", pNdb->getNdbError());
delete pNdb;
return 2;
}
if(bCreateTable)
{
printf("Create CallContext table\n");
if (bStoredTable)
{
if (CreateCallContextTable(pNdb, c_szTableNameStored, true))
{
printf("Create table failed\n");
delete pNdb;
return 3;
}
}
else
{
if (CreateCallContextTable(pNdb, c_szTableNameTemp, false))
{
printf("Create table failed\n");
delete pNdb;
return 3;
}
}
}
if(g_nNumThreads>0)
{
printf("creating %d threads\n", (int)g_nNumThreads);
if(g_bInsertInitial)
{
printf("each thread will insert %ld initial records, total %ld inserts\n",
g_nMaxContextIdPerThread, g_nNumThreads*g_nMaxContextIdPerThread);
}
if(g_bVerifyInitial)
{
printf("each thread will verify %ld initial records, total %ld reads\n",
g_nMaxContextIdPerThread, g_nNumThreads*g_nMaxContextIdPerThread);
}
g_nNumberOfInitialInsert = 0;
g_nNumberOfInitialVerify = 0;
NDB_TICKS tStartTime = NdbTick_CurrentMillisecond();
NdbThread* pThreads[256];
int pnStartingRecordNum[256];
int ij;
for(ij=0;ij<g_nNumThreads;ij++)
{
pnStartingRecordNum[ij] = (ij*g_nMaxContextIdPerThread) + nSeed;
}
for(ij=0;ij<g_nNumThreads;ij++)
{
pThreads[ij] = NdbThread_Create(RuntimeCallContext,
(void**)(pnStartingRecordNum+ij),
0, "RuntimeCallContext", NDB_THREAD_PRIO_LOW);
}
//Wait for the threads to finish
for(ij=0;ij<g_nNumThreads;ij++)
{
void* status;
NdbThread_WaitFor(pThreads[ij], &status);
}
NDB_TICKS tEndTime = NdbTick_CurrentMillisecond();
//Print time taken
printf("Time Taken for %ld Calls is %ld msec (= %ld calls/sec)\n",
g_nNumCallsProcessed,
(long)(tEndTime-tStartTime),
(long)((1000*g_nNumCallsProcessed)/(tEndTime-tStartTime)));
if(g_bInsertInitial)
printf("successfully inserted %ld tuples\n", g_nNumberOfInitialInsert);
if(g_bVerifyInitial)
printf("successfully verified %ld tuples\n", g_nNumberOfInitialVerify);
}
delete pNdb;
#ifdef NDB_WIN32
CloseHandle(hShutdownEvent);
#endif
NdbMutex_Destroy(g_pNdbMutexIncrement);
NdbMutex_Destroy(g_pNdbMutexPrintf);
if(g_bReport)
{
ReportResponseTimeStatistics("Calls", g_plCountMillisecForCall, c_nMaxMillisecForAllCall);
ReportResponseTimeStatistics("Transactions", g_plCountMillisecForTrans, c_nMaxMillisecForAllTrans);
delete[] g_plCountMillisecForCall;
delete[] g_plCountMillisecForTrans;
}
return 0;
}
void
ndb_init_internal()
{
if (!g_ndb_connection_mutex)
g_ndb_connection_mutex = NdbMutex_Create();
}
Ndb_cluster_connection_impl::Ndb_cluster_connection_impl(const char *
connect_string)
: Ndb_cluster_connection(*this),
m_optimized_node_selection(1),
m_name(0),
m_run_connect_thread(0),
m_event_add_drop_mutex(0),
m_latest_trans_gci(0)
{
DBUG_ENTER("Ndb_cluster_connection");
DBUG_PRINT("enter",("Ndb_cluster_connection this=0x%lx", (long) this));
if (!m_event_add_drop_mutex)
m_event_add_drop_mutex= NdbMutex_Create();
g_eventLogger.createConsoleHandler();
g_eventLogger.setCategory("NdbApi");
g_eventLogger.enable(Logger::LL_ON, Logger::LL_ERROR);
m_connect_thread= 0;
m_connect_callback= 0;
#ifdef VM_TRACE
if (ndb_print_state_mutex == NULL)
ndb_print_state_mutex= NdbMutex_Create();
#endif
m_config_retriever=
new ConfigRetriever(connect_string, NDB_VERSION, NODE_TYPE_API);
if (m_config_retriever->hasError())
{
printf("Could not initialize handle to management server: %s\n",
m_config_retriever->getErrorString());
delete m_config_retriever;
m_config_retriever= 0;
}
if (m_name)
{
NdbMgmHandle h= m_config_retriever->get_mgmHandle();
ndb_mgm_set_name(h, m_name);
}
m_transporter_facade= new TransporterFacade();
NdbMutex_Lock(g_ndb_connection_mutex);
if(g_ndb_connection_count++ == 0){
NdbDictionary::Column::FRAGMENT=
NdbColumnImpl::create_pseudo("NDB$FRAGMENT");
NdbDictionary::Column::FRAGMENT_FIXED_MEMORY=
NdbColumnImpl::create_pseudo("NDB$FRAGMENT_FIXED_MEMORY");
NdbDictionary::Column::FRAGMENT_VARSIZED_MEMORY=
NdbColumnImpl::create_pseudo("NDB$FRAGMENT_VARSIZED_MEMORY");
NdbDictionary::Column::ROW_COUNT=
NdbColumnImpl::create_pseudo("NDB$ROW_COUNT");
NdbDictionary::Column::COMMIT_COUNT=
NdbColumnImpl::create_pseudo("NDB$COMMIT_COUNT");
NdbDictionary::Column::ROW_SIZE=
NdbColumnImpl::create_pseudo("NDB$ROW_SIZE");
NdbDictionary::Column::RANGE_NO=
NdbColumnImpl::create_pseudo("NDB$RANGE_NO");
NdbDictionary::Column::DISK_REF=
NdbColumnImpl::create_pseudo("NDB$DISK_REF");
NdbDictionary::Column::RECORDS_IN_RANGE=
NdbColumnImpl::create_pseudo("NDB$RECORDS_IN_RANGE");
NdbDictionary::Column::ROWID=
NdbColumnImpl::create_pseudo("NDB$ROWID");
NdbDictionary::Column::ROW_GCI=
NdbColumnImpl::create_pseudo("NDB$ROW_GCI");
NdbDictionary::Column::ANY_VALUE=
NdbColumnImpl::create_pseudo("NDB$ANY_VALUE");
NdbDictionary::Column::COPY_ROWID=
NdbColumnImpl::create_pseudo("NDB$COPY_ROWID");
}
NdbMutex_Unlock(g_ndb_connection_mutex);
DBUG_VOID_RETURN;
}
***************************************************************/
/***************************************************************
* L O C A L D A T A S T R U C T U R E S *
***************************************************************/
/***************************************************************
* L O C A L F U N C T I O N S *
***************************************************************/
#ifndef NDB_WIN32
#include <unistd.h>
#endif
static NdbMutex* startupMutex = NdbMutex_Create();
Ndb*
asyncDbConnect(int parallellism){
NdbMutex_Lock(startupMutex);
Ndb * pNDB = new Ndb("");
pNDB->init(parallellism + 1);
while(pNDB->waitUntilReady() != 0){
}
NdbMutex_Unlock(startupMutex);
return pNDB;
}
Ndb_cluster_connection_impl::
Ndb_cluster_connection_impl(const char * connect_string,
Ndb_cluster_connection *main_connection,
int force_api_nodeid)
: Ndb_cluster_connection(*this),
m_main_connection(main_connection),
m_optimized_node_selection(1),
m_run_connect_thread(0),
m_latest_trans_gci(0),
m_first_ndb_object(0),
m_latest_error_msg(),
m_latest_error(0),
m_max_trans_id(0),
m_multi_wait_group(0)
{
DBUG_ENTER("Ndb_cluster_connection");
DBUG_PRINT("enter",("Ndb_cluster_connection this=0x%lx", (long) this));
NdbMutex_Lock(g_ndb_connection_mutex);
if(g_ndb_connection_count++ == 0)
{
NdbColumnImpl::create_pseudo_columns();
g_eventLogger->createConsoleHandler();
g_eventLogger->setCategory("NdbApi");
g_eventLogger->enable(Logger::LL_ON, Logger::LL_ERROR);
/*
Disable repeated message handling as it interfers
with mysqld logging, in which case messages come out
of order. Same applies for regular ndbapi user.
*/
g_eventLogger->setRepeatFrequency(0);
#ifdef VM_TRACE
ndb_print_state_mutex= NdbMutex_Create();
#endif
}
NdbMutex_Unlock(g_ndb_connection_mutex);
m_event_add_drop_mutex= NdbMutex_Create();
m_new_delete_ndb_mutex = NdbMutex_Create();
m_connect_thread= 0;
m_connect_callback= 0;
/* Clear global stats baseline */
memset(globalApiStatsBaseline, 0, sizeof(globalApiStatsBaseline));
m_config_retriever=
new ConfigRetriever(connect_string, force_api_nodeid,
NDB_VERSION, NDB_MGM_NODE_TYPE_API);
if (m_config_retriever->hasError())
{
m_latest_error= 1;
m_latest_error_msg.assfmt
("Could not initialize handle to management server: %s",
m_config_retriever->getErrorString());
printf("%s\n", get_latest_error_msg());
}
if (!m_main_connection)
{
m_globalDictCache = new GlobalDictCache;
m_transporter_facade= new TransporterFacade(m_globalDictCache);
}
else
{
assert(m_main_connection->m_impl.m_globalDictCache != NULL);
m_globalDictCache = 0;
m_transporter_facade=
new TransporterFacade(m_main_connection->m_impl.m_globalDictCache);
// The secondary connection can't use same nodeid, clear the nodeid
// in ConfigRetriver to avoid asking for the same nodeid again
m_config_retriever->setNodeId(0);
}
DBUG_VOID_RETURN;
}
