bool Dbinfo::find_next(Ndbinfo::ScanCursor* cursor) const
{
Uint32 node = refToNode(cursor->currRef);
Uint32 block = refToBlock(cursor->currRef);
const Uint32 instance = refToInstance(cursor->currRef);
ndbrequire(instance == 0);
if (node == 0)
{
jam();
// First 'find_next'
ndbrequire(block == 0);
cursor->currRef = switchRef(dbinfo_blocks[0], getOwnNodeId());
return true;
}
if (block)
{
jam();
// Find next block
ndbrequire(node == getOwnNodeId());
block = find_next_block(block);
if (block)
{
jam();
cursor->currRef = switchRef(block, node);
return true;
}
}
// Nothing more to scan
cursor->currRef = 0;
return false;
}
void
DblqhProxy::sendGCP_SAVECONF(Signal* signal, Uint32 ssId)
{
Ss_GCP_SAVEREQ& ss = ssFind<Ss_GCP_SAVEREQ>(ssId);
if (!lastReply(ss))
return;
if (ss.m_error == 0) {
GCPSaveConf* conf = (GCPSaveConf*)signal->getDataPtrSend();
conf->dihPtr = ss.m_req.dihPtr;
conf->nodeId = getOwnNodeId();
conf->gci = ss.m_req.gci;
sendSignal(ss.m_req.dihBlockRef, GSN_GCP_SAVECONF,
signal, GCPSaveConf::SignalLength, JBB);
} else {
jam();
GCPSaveRef* ref = (GCPSaveRef*)signal->getDataPtrSend();
ref->dihPtr = ss.m_req.dihPtr;
ref->nodeId = getOwnNodeId();
ref->gci = ss.m_req.gci;
ref->errorCode = ss.m_error;
sendSignal(ss.m_req.dihBlockRef, GSN_GCP_SAVEREF,
signal, GCPSaveRef::SignalLength, JBB);
}
ssRelease<Ss_GCP_SAVEREQ>(ssId);
}
void
DbgdmProxy::sendTAB_COMMITCONF(Signal* signal, Uint32 ssId)
{
Ss_TAB_COMMITREQ& ss = ssFind<Ss_TAB_COMMITREQ>(ssId);
BlockReference dictRef = ss.m_req.senderRef;
if (!lastReply(ss))
return;
if (ss.m_error == 0) {
jam();
TabCommitConf* conf = (TabCommitConf*)signal->getDataPtrSend();
conf->senderData = ss.m_req.senderData;
conf->nodeId = getOwnNodeId();
conf->tableId = ss.m_req.tableId;
sendSignal(dictRef, GSN_TAB_COMMITCONF,
signal, TabCommitConf::SignalLength, JBB);
} else {
jam();
TabCommitRef* ref = (TabCommitRef*)signal->getDataPtrSend();
ref->senderData = ss.m_req.senderData;
ref->nodeId = getOwnNodeId();
ref->tableId = ss.m_req.tableId;
sendSignal(dictRef, GSN_TAB_COMMITREF,
signal, TabCommitRef::SignalLength, JBB);
return;
}
ssRelease<Ss_TAB_COMMITREQ>(ssId);
}
void
ClusterMgr::reportConnected(NodeId nodeId)
{
DBUG_ENTER("ClusterMgr::reportConnected");
DBUG_PRINT("info", ("nodeId: %u", nodeId));
/**
* Ensure that we are sending heartbeat every 100 ms
* until we have got the first reply from NDB providing
* us with the real time-out period to use.
*/
assert(nodeId > 0 && nodeId < MAX_NODES);
if (nodeId == getOwnNodeId())
{
noOfConnectedNodes--; // Don't count self...
}
noOfConnectedNodes++;
Node & cm_node = theNodes[nodeId];
trp_node & theNode = cm_node;
cm_node.hbMissed = 0;
cm_node.hbCounter = 0;
cm_node.hbFrequency = 0;
assert(theNode.is_connected() == false);
/**
* make sure the node itself is marked connected even
* if first API_REGCONF has not arrived
*/
theNode.set_connected(true);
theNode.m_state.m_connected_nodes.set(nodeId);
theNode.m_info.m_version = 0;
theNode.compatible = true;
theNode.nfCompleteRep = true;
theNode.m_node_fail_rep = false;
theNode.m_state.startLevel = NodeState::SL_NOTHING;
theNode.minDbVersion = 0;
/**
* We know that we have clusterMgrThreadMutex and trp_client::mutex
* but we don't know if we are polling...and for_each can
* only be used by a poller...
*
* Send signal to self, so that we can do this when receiving a signal
*/
NdbApiSignal signal(numberToRef(API_CLUSTERMGR, getOwnNodeId()));
signal.theVerId_signalNumber = GSN_CONNECT_REP;
signal.theReceiversBlockNumber = API_CLUSTERMGR;
signal.theTrace = 0;
signal.theLength = 1;
signal.getDataPtrSend()[0] = nodeId;
raw_sendSignal(&signal, getOwnNodeId());
DBUG_VOID_RETURN;
}
void
DblqhProxy::execEXEC_SR_2(Signal* signal, GlobalSignalNumber gsn)
{
ndbrequire(signal->getLength() == Ss_EXEC_SR_2::Sig::SignalLength);
const Ss_EXEC_SR_2::Sig* sig =
(const Ss_EXEC_SR_2::Sig*)signal->getDataPtr();
Uint32 ssId = getSsId(sig);
bool found = false;
Ss_EXEC_SR_2& ss = ssFindSeize<Ss_EXEC_SR_2>(ssId, &found);
if (!found) {
jam();
setMask(ss);
}
ndbrequire(sig->nodeId == getOwnNodeId());
if (ss.m_sigcount == 0) {
jam();
ss.m_gsn = gsn;
ss.m_sig = *sig;
} else {
jam();
ndbrequire(ss.m_gsn == gsn);
ndbrequire(memcmp(&ss.m_sig, sig, sizeof(*sig)) == 0);
}
ss.m_sigcount++;
// reversed roles
recvCONF(signal, ss);
}
void
DblqhProxy::sendLQH_TRANSCONF(Signal* signal, Uint32 ssId)
{
Ss_LQH_TRANSREQ& ss = ssFind<Ss_LQH_TRANSREQ>(ssId);
if (ss.m_conf.operationStatus != LqhTransConf::LastTransConf) {
jam();
LqhTransConf* conf = (LqhTransConf*)signal->getDataPtrSend();
*conf = ss.m_conf;
conf->tcRef = ss.m_req.senderData;
sendSignal(ss.m_req.senderRef, GSN_LQH_TRANSCONF,
signal, LqhTransConf::SignalLength, JBB);
// more replies from this worker
skipConf(ss);
}
if (!lastReply(ss))
return;
if (ss.m_error == 0) {
jam();
LqhTransConf* conf = (LqhTransConf*)signal->getDataPtrSend();
conf->tcRef = ss.m_req.senderData;
conf->lqhNodeId = getOwnNodeId();
conf->operationStatus = LqhTransConf::LastTransConf;
sendSignal(ss.m_req.senderRef, GSN_LQH_TRANSCONF,
signal, LqhTransConf::SignalLength, JBB);
} else {
ndbrequire(false);
}
ssRelease<Ss_LQH_TRANSREQ>(ssId);
}
void
ClusterMgr::startup()
{
assert(theStop == -1);
Uint32 nodeId = getOwnNodeId();
Node & cm_node = theNodes[nodeId];
trp_node & theNode = cm_node;
assert(theNode.defined);
lock();
theFacade.doConnect(nodeId);
flush_send_buffers();
unlock();
for (Uint32 i = 0; i<3000; i++)
{
theFacade.request_connection_check();
start_poll();
do_poll(0);
complete_poll();
if (theNode.is_connected())
break;
NdbSleep_MilliSleep(20);
}
assert(theNode.is_connected());
Guard g(clusterMgrThreadMutex);
/* Signalling to creating thread that we are done with thread startup */
theStop = 0;
NdbCondition_Broadcast(waitForHBCond);
}
void
Ndbfs::execREAD_CONFIG_REQ(Signal* signal)
{
const ReadConfigReq * req = (ReadConfigReq*)signal->getDataPtr();
Uint32 ref = req->senderRef;
Uint32 senderData = req->senderData;
const ndb_mgm_configuration_iterator * p =
m_ctx.m_config.getOwnConfigIterator();
ndbrequire(p != 0);
theFileSystemPath.assfmt("%sndb_%u_fs%s", m_ctx.m_config.fileSystemPath(),
getOwnNodeId(), DIR_SEPARATOR);
theBackupFilePath.assign(m_ctx.m_config.backupFilePath());
theRequestPool = new Pool<Request>;
m_maxFiles = 0;
ndb_mgm_get_int_parameter(p, CFG_DB_MAX_OPEN_FILES, &m_maxFiles);
Uint32 noIdleFiles = 27;
ndb_mgm_get_int_parameter(p, CFG_DB_INITIAL_OPEN_FILES, &noIdleFiles);
if (noIdleFiles > m_maxFiles && m_maxFiles != 0)
m_maxFiles = noIdleFiles;
// Create idle AsyncFiles
for (Uint32 i = 0; i < noIdleFiles; i++){
theIdleFiles.push_back(createAsyncFile());
}
ReadConfigConf * conf = (ReadConfigConf*)signal->getDataPtrSend();
conf->senderRef = reference();
conf->senderData = senderData;
sendSignal(ref, GSN_READ_CONFIG_CONF, signal,
ReadConfigConf::SignalLength, JBB);
}
void
ClusterMgr::startup()
{
assert(theStop == -1);
Uint32 nodeId = getOwnNodeId();
Node & cm_node = theNodes[nodeId];
trp_node & theNode = cm_node;
assert(theNode.defined);
lock();
theFacade.doConnect(nodeId);
flush_send_buffers();
unlock();
for (Uint32 i = 0; i<3000; i++)
{
lock();
theFacade.theTransporterRegistry->update_connections();
flush_send_buffers();
unlock();
if (theNode.is_connected())
break;
NdbSleep_MilliSleep(20);
}
assert(theNode.is_connected());
Guard g(clusterMgrThreadMutex);
theStop = 0;
NdbCondition_Broadcast(waitForHBCond);
}
void
DblqhProxy::execLQHFRAGREQ(Signal* signal)
{
LqhFragReq* req = (LqhFragReq*)signal->getDataPtrSend();
Uint32 instance = getInstanceKey(req->tableId, req->fragId);
// wl4391_todo impl. method that fakes senders block-ref
sendSignal(numberToRef(DBLQH, instance, getOwnNodeId()),
GSN_LQHFRAGREQ, signal, signal->getLength(), JBB);
}
void
ClusterMgr::execDISCONNECT_REP(const NdbApiSignal* sig,
const LinearSectionPtr ptr[])
{
const DisconnectRep * rep = CAST_CONSTPTR(DisconnectRep, sig->getDataPtr());
Uint32 nodeId = rep->nodeId;
assert(nodeId > 0 && nodeId < MAX_NODES);
Node & cm_node = theNodes[nodeId];
trp_node & theNode = cm_node;
bool node_failrep = theNode.m_node_fail_rep;
set_node_dead(theNode);
theNode.set_connected(false);
noOfConnectedNodes--;
if (noOfConnectedNodes == 0)
{
if (!global_flag_skip_invalidate_cache &&
theFacade.m_globalDictCache)
{
theFacade.m_globalDictCache->lock();
theFacade.m_globalDictCache->invalidate_all();
theFacade.m_globalDictCache->unlock();
m_connect_count ++;
m_cluster_state = CS_waiting_for_clean_cache;
}
if (m_auto_reconnect == 0)
{
theStop = 2;
}
}
if (node_failrep == false)
{
/**
* Inform API
*/
NdbApiSignal signal(numberToRef(API_CLUSTERMGR, getOwnNodeId()));
signal.theVerId_signalNumber = GSN_NODE_FAILREP;
signal.theReceiversBlockNumber = API_CLUSTERMGR;
signal.theTrace = 0;
signal.theLength = NodeFailRep::SignalLengthLong;
NodeFailRep * rep = CAST_PTR(NodeFailRep, signal.getDataPtrSend());
rep->failNo = 0;
rep->masterNodeId = 0;
rep->noOfNodes = 1;
NodeBitmask::clear(rep->theAllNodes);
NodeBitmask::set(rep->theAllNodes, nodeId);
execNODE_FAILREP(&signal, 0);
}
}
void Qmgr::initData()
{
creadyDistCom = ZFALSE;
// Records with constant sizes
nodeRec = new NodeRec[MAX_NODES];
cnoCommitFailedNodes = 0;
c_maxDynamicId = 0;
c_clusterNodes.clear();
c_stopReq.senderRef = 0;
/**
* Check sanity for NodeVersion
*/
ndbrequire((Uint32)NodeInfo::DB == 0);
ndbrequire((Uint32)NodeInfo::API == 1);
ndbrequire((Uint32)NodeInfo::MGM == 2);
NodeRecPtr nodePtr;
nodePtr.i = getOwnNodeId();
ptrAss(nodePtr, nodeRec);
nodePtr.p->blockRef = reference();
c_connectedNodes.set(getOwnNodeId());
setNodeInfo(getOwnNodeId()).m_version = NDB_VERSION;
/**
* Timeouts
*/
const ndb_mgm_configuration_iterator * p =
m_ctx.m_config.getOwnConfigIterator();
ndbrequire(p != 0);
Uint32 hbDBAPI = 1500;
ndb_mgm_get_int_parameter(p, CFG_DB_API_HEARTBEAT_INTERVAL, &hbDBAPI);
setHbApiDelay(hbDBAPI);
}//Qmgr::initData()
void
DblqhProxy::execLQHFRAGREQ(Signal* signal)
{
LqhFragReq* req = (LqhFragReq*)signal->getDataPtrSend();
Uint32 instance = getInstanceKey(req->tableId, req->fragId);
/* Ensure instance hasn't quietly mapped back to proxy! */
ndbrequire(signal->getSendersBlockRef() != reference());
// wl4391_todo impl. method that fakes senders block-ref
sendSignal(numberToRef(DBLQH, instance, getOwnNodeId()),
GSN_LQHFRAGREQ, signal, signal->getLength(), JBB);
}
void
DblqhProxy::checkSendEMPTY_LCP_CONF_impl(Signal* signal)
{
ndbrequire(!c_lcpRecord.m_empty_lcp_req.isclear());
EmptyLcpRep * rep = (EmptyLcpRep*)signal->getDataPtrSend();
EmptyLcpConf * conf = (EmptyLcpConf*)rep->conf;
switch(c_lcpRecord.m_state){
case LcpRecord::L_IDLE:
jam();
conf->idle = true;
break;
case LcpRecord::L_STARTING:
jam();
return;
case LcpRecord::L_RUNNING:{
jam();
if (getNoOfOutstanding(c_lcpRecord) == 0)
{
jam();
/**
* Given that we wait for all ongoing...
* we can simply return last LCP_FRAG_ORD sent to us
*/
conf->tableId = c_lcpRecord.m_last_lcp_frag_ord.tableId;
conf->fragmentId = c_lcpRecord.m_last_lcp_frag_ord.fragmentId;
conf->lcpId = c_lcpRecord.m_last_lcp_frag_ord.lcpId;
conf->lcpNo = c_lcpRecord.m_last_lcp_frag_ord.lcpNo;
break;
}
return;
}
case LcpRecord::L_COMPLETING_1:
jam();
case LcpRecord::L_COMPLETING_2:
jam();
case LcpRecord::L_COMPLETING_3:
jam();
return;
}
conf->senderNodeId = getOwnNodeId();
c_lcpRecord.m_empty_lcp_req.copyto(NdbNodeBitmask::Size, rep->receiverGroup);
sendSignal(DBDIH_REF, GSN_EMPTY_LCP_REP, signal,
EmptyLcpRep::SignalLength + EmptyLcpConf::SignalLength, JBB);
c_lcpRecord.m_empty_lcp_req.clear();
}
void
ClusterMgr::reportDisconnected(NodeId nodeId)
{
assert(nodeId > 0 && nodeId < MAX_NODES);
assert(noOfConnectedNodes > 0);
/**
* We know that we have trp_client lock
* but we don't know if we are polling...and for_each can
* only be used by a poller...
*
* Send signal to self, so that we can do this when receiving a signal
*/
NdbApiSignal signal(numberToRef(API_CLUSTERMGR, getOwnNodeId()));
signal.theVerId_signalNumber = GSN_DISCONNECT_REP;
signal.theReceiversBlockNumber = API_CLUSTERMGR;
signal.theTrace = 0;
signal.theLength = DisconnectRep::SignalLength;
DisconnectRep * rep = CAST_PTR(DisconnectRep, signal.getDataPtrSend());
rep->nodeId = nodeId;
rep->err = 0;
raw_sendSignal(&signal, getOwnNodeId());
}
void
DbtcProxy::execTAKE_OVERTCCONF(Signal* signal)
{
jamEntry();
if (!checkNodeFailSequence(signal))
{
jam();
return;
}
for (Uint32 i = 0; i < c_workers; i++)
{
jam();
Uint32 ref = numberToRef(number(), workerInstance(i), getOwnNodeId());
sendSignal(ref, GSN_TAKE_OVERTCCONF, signal,
signal->getLength(),
JBB);
}
}
void
DblqhProxy::completeLCP_1(Signal* signal)
{
ndbrequire(c_lcpRecord.m_state == LcpRecord::L_RUNNING);
c_lcpRecord.m_state = LcpRecord::L_COMPLETING_1;
ndbrequire(c_lcpRecord.m_complete_outstanding == 0);
/**
* send LCP_FRAG_ORD (lastFragmentFlag = true)
* to all LQH instances...
* they will reply with LCP_COMPLETE_REP
*/
LcpFragOrd* ord = (LcpFragOrd*)signal->getDataPtrSend();
ord->lcpId = c_lcpRecord.m_lcpId;
ord->lastFragmentFlag = true;
for (Uint32 i = 0; i<c_workers; i++)
{
jam();
c_lcpRecord.m_complete_outstanding++;
sendSignal(workerRef(i), GSN_LCP_FRAG_ORD, signal,
LcpFragOrd::SignalLength, JBB);
}
/**
* send END_LCP_REQ to all pgman instances (except "extra" pgman)
* they will reply with END_LCP_CONF
*/
EndLcpReq* req = (EndLcpReq*)signal->getDataPtrSend();
req->senderData= 0;
req->senderRef= reference();
req->backupPtr= 0;
req->backupId= c_lcpRecord.m_lcpId;
for (Uint32 i = 0; i<c_workers; i++)
{
jam();
c_lcpRecord.m_complete_outstanding++;
sendSignal(numberToRef(PGMAN, workerInstance(i), getOwnNodeId()),
GSN_END_LCP_REQ, signal, EndLcpReq::SignalLength, JBB);
}
}
// GSN_EXEC_FRAGCONF
void
DblqhProxy::execEXEC_FRAGCONF(Signal* signal)
{
Uint32 ref = signal->theData[1];
if (refToNode(ref) == getOwnNodeId())
{
jam();
sendSignal(ref, GSN_EXEC_FRAGCONF, signal, 1, JBB);
}
else if (ndb_route_exec_frag(getNodeInfo(refToNode(ref)).m_version))
{
jam();
sendSignal(numberToRef(DBLQH, refToNode(ref)), GSN_EXEC_FRAGCONF,
signal, 2, JBB);
}
else
{
jam();
sendSignal(ref, GSN_EXEC_FRAGCONF, signal, 2, JBB);
}
}
void
DblqhProxy::sendSTART_RECREQ_2(Signal* signal, Uint32 ssId)
{
Ss_START_RECREQ_2& ss = ssFind<Ss_START_RECREQ_2>(ssId);
const Ss_START_RECREQ_2::Req* req =
(const Ss_START_RECREQ_2::Req*)signal->getDataPtr();
if (firstReply(ss)) {
ss.m_req = *req;
} else {
jam();
/*
* Fragments can be started from different lcpId's. LGMAN must run
* UNDO until lowest lcpId. Each DBLQH instance computes the lowest
* lcpId in START_FRAGREQ. In MT case the proxy further computes
* the lowest of the lcpId's from worker instances.
*/
if (req->lcpId < ss.m_req.lcpId)
{
jam();
ss.m_req.lcpId = req->lcpId;
}
ndbrequire(ss.m_req.proxyBlockNo == req->proxyBlockNo);
}
if (!lastReply(ss))
return;
{
Ss_START_RECREQ_2::Req* req =
(Ss_START_RECREQ_2::Req*)signal->getDataPtrSend();
*req = ss.m_req;
BlockReference ref = numberToRef(req->proxyBlockNo, getOwnNodeId());
sendSignal(ref, GSN_START_RECREQ, signal,
Ss_START_RECREQ_2::Req::SignalLength, JBB);
}
}
// GSN_EXEC_FRAGREQ
void
DblqhProxy::execEXEC_FRAGREQ(Signal* signal)
{
Uint32 ref = ((ExecFragReq*)signal->getDataPtr())->dst;
if (refToNode(ref) == getOwnNodeId())
{
jam();
sendSignal(ref, GSN_EXEC_FRAGREQ, signal, signal->getLength(), JBB);
}
else if (ndb_route_exec_frag(getNodeInfo(refToNode(ref)).m_version))
{
jam();
sendSignal(numberToRef(DBLQH, refToNode(ref)), GSN_EXEC_FRAGREQ, signal,
signal->getLength(), JBB);
}
else
{
jam();
sendSignal(ref, GSN_EXEC_FRAGREQ, signal,
signal->getLength(), JBB);
}
}
void
DblqhProxy::completeLCP_2(Signal* signal)
{
jamEntry();
ndbrequire(c_lcpRecord.m_state == LcpRecord::L_COMPLETING_1);
c_lcpRecord.m_state = LcpRecord::L_COMPLETING_2;
EndLcpReq* req = (EndLcpReq*)signal->getDataPtrSend();
req->senderData= 0;
req->senderRef= reference();
req->backupPtr= 0;
req->backupId= c_lcpRecord.m_lcpId;
c_lcpRecord.m_complete_outstanding++;
/**
* send to "extra" instance
* that will checkpoint extent-pages
*/
// NOTE: ugly to use MaxLqhWorkers directly
Uint32 instance = c_workers + 1;
sendSignal(numberToRef(PGMAN, instance, getOwnNodeId()),
GSN_END_LCP_REQ, signal, EndLcpReq::SignalLength, JBB);
}
void
DblqhProxy::sendSTART_RECCONF(Signal* signal, Uint32 ssId)
{
Ss_START_RECREQ& ss = ssFind<Ss_START_RECREQ>(ssId);
if (!lastReply(ss))
return;
if (ss.m_error == 0) {
jam();
/**
* There should be no disk-ops in flight here...check it
*/
signal->theData[0] = 12003;
sendSignal(LGMAN_REF, GSN_DUMP_STATE_ORD, signal, 1, JBB);
StartRecConf* conf = (StartRecConf*)signal->getDataPtrSend();
conf->startingNodeId = getOwnNodeId();
conf->senderData = ss.m_req.senderData;
sendSignal(ss.m_req.senderRef, GSN_START_RECCONF,
signal, StartRecConf::SignalLength, JBB);
} else {
ndbrequire(false);
}
{
Uint32 i;
for (i = 0; i < ss.m_req2cnt; i++) {
jam();
Uint32 ssId2 = ss.m_req2[i].m_ssId;
ssRelease<Ss_START_RECREQ_2>(ssId2);
}
}
ssRelease<Ss_START_RECREQ>(ssId);
}
Cmvmi::Cmvmi(Block_context& ctx) :
SimulatedBlock(CMVMI, ctx)
,subscribers(subscriberPool)
{
BLOCK_CONSTRUCTOR(Cmvmi);
Uint32 long_sig_buffer_size;
const ndb_mgm_configuration_iterator * p =
m_ctx.m_config.getOwnConfigIterator();
ndbrequire(p != 0);
ndb_mgm_get_int_parameter(p, CFG_DB_LONG_SIGNAL_BUFFER,
&long_sig_buffer_size);
long_sig_buffer_size= long_sig_buffer_size / 256;
g_sectionSegmentPool.setSize(long_sig_buffer_size,
false,true,true,CFG_DB_LONG_SIGNAL_BUFFER);
// Add received signals
addRecSignal(GSN_CONNECT_REP, &Cmvmi::execCONNECT_REP);
addRecSignal(GSN_DISCONNECT_REP, &Cmvmi::execDISCONNECT_REP);
addRecSignal(GSN_NDB_TAMPER, &Cmvmi::execNDB_TAMPER, true);
addRecSignal(GSN_SET_LOGLEVELORD, &Cmvmi::execSET_LOGLEVELORD);
addRecSignal(GSN_EVENT_REP, &Cmvmi::execEVENT_REP);
addRecSignal(GSN_STTOR, &Cmvmi::execSTTOR);
addRecSignal(GSN_READ_CONFIG_REQ, &Cmvmi::execREAD_CONFIG_REQ);
addRecSignal(GSN_CLOSE_COMREQ, &Cmvmi::execCLOSE_COMREQ);
addRecSignal(GSN_ENABLE_COMORD, &Cmvmi::execENABLE_COMORD);
addRecSignal(GSN_OPEN_COMREQ, &Cmvmi::execOPEN_COMREQ);
addRecSignal(GSN_TEST_ORD, &Cmvmi::execTEST_ORD);
addRecSignal(GSN_TAMPER_ORD, &Cmvmi::execTAMPER_ORD);
addRecSignal(GSN_STOP_ORD, &Cmvmi::execSTOP_ORD);
addRecSignal(GSN_START_ORD, &Cmvmi::execSTART_ORD);
addRecSignal(GSN_EVENT_SUBSCRIBE_REQ,
&Cmvmi::execEVENT_SUBSCRIBE_REQ);
addRecSignal(GSN_DUMP_STATE_ORD, &Cmvmi::execDUMP_STATE_ORD);
addRecSignal(GSN_TESTSIG, &Cmvmi::execTESTSIG);
addRecSignal(GSN_NODE_START_REP, &Cmvmi::execNODE_START_REP, true);
subscriberPool.setSize(5);
const ndb_mgm_configuration_iterator * db = m_ctx.m_config.getOwnConfigIterator();
for(unsigned j = 0; j<LogLevel::LOGLEVEL_CATEGORIES; j++){
Uint32 logLevel;
if(!ndb_mgm_get_int_parameter(db, CFG_MIN_LOGLEVEL+j, &logLevel)){
clogLevel.setLogLevel((LogLevel::EventCategory)j,
logLevel);
}
}
ndb_mgm_configuration_iterator * iter = m_ctx.m_config.getClusterConfigIterator();
for(ndb_mgm_first(iter); ndb_mgm_valid(iter); ndb_mgm_next(iter)){
jam();
Uint32 nodeId;
Uint32 nodeType;
ndbrequire(!ndb_mgm_get_int_parameter(iter,CFG_NODE_ID, &nodeId));
ndbrequire(!ndb_mgm_get_int_parameter(iter,CFG_TYPE_OF_SECTION,&nodeType));
switch(nodeType){
case NodeInfo::DB:
c_dbNodes.set(nodeId);
break;
case NodeInfo::API:
case NodeInfo::MGM:
break;
default:
ndbrequire(false);
}
setNodeInfo(nodeId).m_type = nodeType;
}
setNodeInfo(getOwnNodeId()).m_connected = true;
setNodeInfo(getOwnNodeId()).m_version = ndbGetOwnVersion();
}
Backup::Backup(Block_context& ctx, Uint32 instanceNumber) :
SimulatedBlock(BACKUP, ctx, instanceNumber),
c_nodes(c_nodePool),
c_backups(c_backupPool)
{
BLOCK_CONSTRUCTOR(Backup);
c_masterNodeId = getOwnNodeId();
// Add received signals
addRecSignal(GSN_READ_CONFIG_REQ, &Backup::execREAD_CONFIG_REQ);
addRecSignal(GSN_STTOR, &Backup::execSTTOR);
addRecSignal(GSN_DUMP_STATE_ORD, &Backup::execDUMP_STATE_ORD);
addRecSignal(GSN_READ_NODESCONF, &Backup::execREAD_NODESCONF);
addRecSignal(GSN_NODE_FAILREP, &Backup::execNODE_FAILREP);
addRecSignal(GSN_INCL_NODEREQ, &Backup::execINCL_NODEREQ);
addRecSignal(GSN_CONTINUEB, &Backup::execCONTINUEB);
addRecSignal(GSN_READ_CONFIG_REQ, &Backup::execREAD_CONFIG_REQ, true);
addRecSignal(GSN_SCAN_HBREP, &Backup::execSCAN_HBREP);
addRecSignal(GSN_TRANSID_AI, &Backup::execTRANSID_AI);
addRecSignal(GSN_SCAN_FRAGREF, &Backup::execSCAN_FRAGREF);
addRecSignal(GSN_SCAN_FRAGCONF, &Backup::execSCAN_FRAGCONF);
addRecSignal(GSN_BACKUP_TRIG_REQ, &Backup::execBACKUP_TRIG_REQ);
addRecSignal(GSN_TRIG_ATTRINFO, &Backup::execTRIG_ATTRINFO);
addRecSignal(GSN_FIRE_TRIG_ORD, &Backup::execFIRE_TRIG_ORD);
addRecSignal(GSN_LIST_TABLES_CONF, &Backup::execLIST_TABLES_CONF);
addRecSignal(GSN_GET_TABINFOREF, &Backup::execGET_TABINFOREF);
addRecSignal(GSN_GET_TABINFO_CONF, &Backup::execGET_TABINFO_CONF);
addRecSignal(GSN_CREATE_TRIG_IMPL_REF, &Backup::execCREATE_TRIG_IMPL_REF);
addRecSignal(GSN_CREATE_TRIG_IMPL_CONF, &Backup::execCREATE_TRIG_IMPL_CONF);
addRecSignal(GSN_DROP_TRIG_IMPL_REF, &Backup::execDROP_TRIG_IMPL_REF);
addRecSignal(GSN_DROP_TRIG_IMPL_CONF, &Backup::execDROP_TRIG_IMPL_CONF);
addRecSignal(GSN_DIH_SCAN_TAB_CONF, &Backup::execDIH_SCAN_TAB_CONF);
addRecSignal(GSN_DIH_SCAN_GET_NODES_CONF,
&Backup::execDIH_SCAN_GET_NODES_CONF);
addRecSignal(GSN_FSOPENREF, &Backup::execFSOPENREF, true);
addRecSignal(GSN_FSOPENCONF, &Backup::execFSOPENCONF);
addRecSignal(GSN_FSCLOSEREF, &Backup::execFSCLOSEREF, true);
addRecSignal(GSN_FSCLOSECONF, &Backup::execFSCLOSECONF);
addRecSignal(GSN_FSAPPENDREF, &Backup::execFSAPPENDREF, true);
addRecSignal(GSN_FSAPPENDCONF, &Backup::execFSAPPENDCONF);
addRecSignal(GSN_FSREMOVEREF, &Backup::execFSREMOVEREF, true);
addRecSignal(GSN_FSREMOVECONF, &Backup::execFSREMOVECONF);
/*****/
addRecSignal(GSN_BACKUP_REQ, &Backup::execBACKUP_REQ);
addRecSignal(GSN_ABORT_BACKUP_ORD, &Backup::execABORT_BACKUP_ORD);
addRecSignal(GSN_DEFINE_BACKUP_REQ, &Backup::execDEFINE_BACKUP_REQ);
addRecSignal(GSN_DEFINE_BACKUP_REF, &Backup::execDEFINE_BACKUP_REF);
addRecSignal(GSN_DEFINE_BACKUP_CONF, &Backup::execDEFINE_BACKUP_CONF);
addRecSignal(GSN_START_BACKUP_REQ, &Backup::execSTART_BACKUP_REQ);
addRecSignal(GSN_START_BACKUP_REF, &Backup::execSTART_BACKUP_REF);
addRecSignal(GSN_START_BACKUP_CONF, &Backup::execSTART_BACKUP_CONF);
addRecSignal(GSN_BACKUP_FRAGMENT_REQ, &Backup::execBACKUP_FRAGMENT_REQ);
addRecSignal(GSN_BACKUP_FRAGMENT_REF, &Backup::execBACKUP_FRAGMENT_REF);
addRecSignal(GSN_BACKUP_FRAGMENT_CONF, &Backup::execBACKUP_FRAGMENT_CONF);
addRecSignal(GSN_BACKUP_FRAGMENT_COMPLETE_REP,
&Backup::execBACKUP_FRAGMENT_COMPLETE_REP);
addRecSignal(GSN_STOP_BACKUP_REQ, &Backup::execSTOP_BACKUP_REQ);
addRecSignal(GSN_STOP_BACKUP_REF, &Backup::execSTOP_BACKUP_REF);
addRecSignal(GSN_STOP_BACKUP_CONF, &Backup::execSTOP_BACKUP_CONF);
//addRecSignal(GSN_BACKUP_STATUS_REQ, &Backup::execBACKUP_STATUS_REQ);
//addRecSignal(GSN_BACKUP_STATUS_CONF, &Backup::execBACKUP_STATUS_CONF);
addRecSignal(GSN_UTIL_SEQUENCE_REF, &Backup::execUTIL_SEQUENCE_REF);
addRecSignal(GSN_UTIL_SEQUENCE_CONF, &Backup::execUTIL_SEQUENCE_CONF);
addRecSignal(GSN_WAIT_GCP_REF, &Backup::execWAIT_GCP_REF);
addRecSignal(GSN_WAIT_GCP_CONF, &Backup::execWAIT_GCP_CONF);
addRecSignal(GSN_BACKUP_LOCK_TAB_CONF, &Backup::execBACKUP_LOCK_TAB_CONF);
addRecSignal(GSN_BACKUP_LOCK_TAB_REF, &Backup::execBACKUP_LOCK_TAB_REF);
addRecSignal(GSN_LCP_STATUS_REQ, &Backup::execLCP_STATUS_REQ);
/**
* Testing
*/
addRecSignal(GSN_BACKUP_REF, &Backup::execBACKUP_REF);
addRecSignal(GSN_BACKUP_CONF, &Backup::execBACKUP_CONF);
addRecSignal(GSN_BACKUP_ABORT_REP, &Backup::execBACKUP_ABORT_REP);
addRecSignal(GSN_BACKUP_COMPLETE_REP, &Backup::execBACKUP_COMPLETE_REP);
addRecSignal(GSN_LCP_PREPARE_REQ, &Backup::execLCP_PREPARE_REQ);
addRecSignal(GSN_END_LCPREQ, &Backup::execEND_LCPREQ);
addRecSignal(GSN_DBINFO_SCANREQ, &Backup::execDBINFO_SCANREQ);
}
void
ClusterMgr::threadMain()
{
startup();
NdbApiSignal signal(numberToRef(API_CLUSTERMGR, theFacade.ownId()));
signal.theVerId_signalNumber = GSN_API_REGREQ;
signal.theTrace = 0;
signal.theLength = ApiRegReq::SignalLength;
ApiRegReq * req = CAST_PTR(ApiRegReq, signal.getDataPtrSend());
req->ref = numberToRef(API_CLUSTERMGR, theFacade.ownId());
req->version = NDB_VERSION;
req->mysql_version = NDB_MYSQL_VERSION_D;
NdbApiSignal nodeFail_signal(numberToRef(API_CLUSTERMGR, getOwnNodeId()));
nodeFail_signal.theVerId_signalNumber = GSN_NODE_FAILREP;
nodeFail_signal.theReceiversBlockNumber = API_CLUSTERMGR;
nodeFail_signal.theTrace = 0;
nodeFail_signal.theLength = NodeFailRep::SignalLengthLong;
NDB_TICKS timeSlept = 100;
NDB_TICKS now = NdbTick_CurrentMillisecond();
while(!theStop)
{
/* Sleep at 100ms between each heartbeat check */
NDB_TICKS before = now;
for (Uint32 i = 0; i<5; i++)
{
NdbSleep_MilliSleep(20);
{
Guard g(clusterMgrThreadMutex);
/**
* Protect from ArbitMgr sending signals while we poll
*/
start_poll();
do_poll(0);
complete_poll();
}
}
now = NdbTick_CurrentMillisecond();
timeSlept = (now - before);
if (m_cluster_state == CS_waiting_for_clean_cache &&
theFacade.m_globalDictCache)
{
if (!global_flag_skip_waiting_for_clean_cache)
{
theFacade.m_globalDictCache->lock();
unsigned sz= theFacade.m_globalDictCache->get_size();
theFacade.m_globalDictCache->unlock();
if (sz)
continue;
}
m_cluster_state = CS_waiting_for_first_connect;
}
NodeFailRep * nodeFailRep = CAST_PTR(NodeFailRep,
nodeFail_signal.getDataPtrSend());
nodeFailRep->noOfNodes = 0;
NodeBitmask::clear(nodeFailRep->theAllNodes);
lock();
for (int i = 1; i < MAX_NODES; i++){
/**
* Send register request (heartbeat) to all available nodes
* at specified timing intervals
*/
const NodeId nodeId = i;
// Check array bounds + don't allow node 0 to be touched
assert(nodeId > 0 && nodeId < MAX_NODES);
Node & cm_node = theNodes[nodeId];
trp_node & theNode = cm_node;
if (!theNode.defined)
continue;
if (theNode.is_connected() == false){
theFacade.doConnect(nodeId);
continue;
}
if (!theNode.compatible){
continue;
}
if (nodeId == getOwnNodeId() && theNode.is_confirmed())
{
/**
* Don't send HB to self more than once
* (once needed to avoid weird special cases in e.g ConfigManager)
*/
continue;
}
cm_node.hbCounter += (Uint32)timeSlept;
if (cm_node.hbCounter >= m_max_api_reg_req_interval ||
cm_node.hbCounter >= cm_node.hbFrequency)
{
/**
* It is now time to send a new Heartbeat
*/
if (cm_node.hbCounter >= cm_node.hbFrequency)
{
cm_node.hbMissed++;
cm_node.hbCounter = 0;
}
if (theNode.m_info.m_type != NodeInfo::DB)
signal.theReceiversBlockNumber = API_CLUSTERMGR;
else
signal.theReceiversBlockNumber = QMGR;
#ifdef DEBUG_REG
ndbout_c("ClusterMgr: Sending API_REGREQ to node %d", (int)nodeId);
#endif
raw_sendSignal(&signal, nodeId);
}//if
if (cm_node.hbMissed == 4 && cm_node.hbFrequency > 0)
{
nodeFailRep->noOfNodes++;
NodeBitmask::set(nodeFailRep->theAllNodes, nodeId);
}
}
flush_send_buffers();
unlock();
if (nodeFailRep->noOfNodes)
{
lock();
raw_sendSignal(&nodeFail_signal, getOwnNodeId());
flush_send_buffers();
unlock();
}
}
}
void
DblqhProxy::execLCP_FRAG_ORD(Signal* signal)
{
ndbrequire(signal->getLength() == LcpFragOrd::SignalLength);
const LcpFragOrd* req = (const LcpFragOrd*)signal->getDataPtr();
const LcpFragOrd req_copy = *req;
bool lcp_complete_ord = req->lastFragmentFlag;
if (c_lcpRecord.m_state == LcpRecord::L_IDLE)
{
jam();
D("LCP: start" << V(req->lcpId));
c_lcpRecord.m_state = LcpRecord::L_STARTING;
c_lcpRecord.m_lcpId = req->lcpId;
c_lcpRecord.m_lcp_frag_rep_cnt = 0;
c_lcpRecord.m_lcp_frag_ord_cnt = 0;
c_lcpRecord.m_complete_outstanding = 0;
c_lcpRecord.m_lastFragmentFlag = false;
c_lcpRecord.m_empty_lcp_req.clear();
// handle start of LCP in PGMAN and TSMAN
LcpFragOrd* req = (LcpFragOrd*)signal->getDataPtrSend();
*req = req_copy;
EXECUTE_DIRECT(PGMAN, GSN_LCP_FRAG_ORD,
signal, LcpFragOrd::SignalLength);
*req = req_copy;
EXECUTE_DIRECT(TSMAN, GSN_LCP_FRAG_ORD,
signal, LcpFragOrd::SignalLength);
c_lcpRecord.m_state = LcpRecord::L_RUNNING;
}
jam();
D("LCP: continue" << V(req->lcpId) << V(c_lcpRecord.m_lcp_frag_ord_cnt));
ndbrequire(c_lcpRecord.m_state == LcpRecord::L_RUNNING);
ndbrequire(c_lcpRecord.m_lcpId == req->lcpId);
if (lcp_complete_ord)
{
jam();
c_lcpRecord.m_lastFragmentFlag = true;
if (getNoOfOutstanding(c_lcpRecord) == 0)
{
jam();
completeLCP_1(signal);
return;
}
/**
* Wait for all LCP_FRAG_ORD/REP to complete
*/
return;
}
else
{
jam();
c_lcpRecord.m_last_lcp_frag_ord = req_copy;
}
c_lcpRecord.m_lcp_frag_ord_cnt++;
// Forward
ndbrequire(req->tableId < c_tableRecSize);
if (c_tableRec[req->tableId] == 0)
{
jam();
/**
* Send to lqh-0...that will handle it...
*/
sendSignal(workerRef(0),
GSN_LCP_FRAG_ORD, signal, LcpFragOrd::SignalLength, JBB);
}
else
{
jam();
Uint32 instance = getInstanceKey(req->tableId, req->fragmentId);
sendSignal(numberToRef(DBLQH, instance, getOwnNodeId()),
GSN_LCP_FRAG_ORD, signal, LcpFragOrd::SignalLength, JBB);
}
}
void
ClusterMgr::execAPI_REGREQ(const Uint32 * theData) {
const ApiRegReq * const apiRegReq = (ApiRegReq *)&theData[0];
const NodeId nodeId = refToNode(apiRegReq->ref);
#ifdef DEBUG_REG
ndbout_c("ClusterMgr: Recd API_REGREQ from node %d", nodeId);
#endif
assert(nodeId > 0 && nodeId < MAX_NODES);
Node & cm_node = theNodes[nodeId];
trp_node & node = cm_node;
assert(node.defined == true);
assert(node.is_connected() == true);
/*
API nodes send API_REGREQ once to themselves. Other than that, there are
no API-API heart beats.
*/
assert(cm_node.m_info.m_type != NodeInfo::API ||
(nodeId == getOwnNodeId() &&
!cm_node.is_confirmed()));
if(node.m_info.m_version != apiRegReq->version) {
node.m_info.m_version = apiRegReq->version;
node.m_info.m_mysql_version = apiRegReq->mysql_version;
if (node.m_info.m_version < NDBD_SPLIT_VERSION)
node.m_info.m_mysql_version = 0;
if (getMajor(node.m_info.m_version) < getMajor(NDB_VERSION) ||
getMinor(node.m_info.m_version) < getMinor(NDB_VERSION)) {
node.compatible = false;
} else {
node.compatible = true;
}
}
NdbApiSignal signal(numberToRef(API_CLUSTERMGR, theFacade.ownId()));
signal.theVerId_signalNumber = GSN_API_REGCONF;
signal.theReceiversBlockNumber = API_CLUSTERMGR;
signal.theTrace = 0;
signal.theLength = ApiRegConf::SignalLength;
ApiRegConf * const conf = CAST_PTR(ApiRegConf, signal.getDataPtrSend());
conf->qmgrRef = numberToRef(API_CLUSTERMGR, theFacade.ownId());
conf->version = NDB_VERSION;
conf->mysql_version = NDB_MYSQL_VERSION_D;
/*
This is the frequency (in centiseonds) at which we want the other node
to send API_REGREQ messages.
*/
conf->apiHeartbeatFrequency = m_hbFrequency/10;
conf->minDbVersion= 0;
conf->nodeState= node.m_state;
node.set_confirmed(true);
if (safe_sendSignal(&signal, nodeId) != 0)
node.set_confirmed(false);
}
void
ClusterMgr::threadMain()
{
startup();
NdbApiSignal signal(numberToRef(API_CLUSTERMGR, theFacade.ownId()));
signal.theVerId_signalNumber = GSN_API_REGREQ;
signal.theTrace = 0;
signal.theLength = ApiRegReq::SignalLength;
ApiRegReq * req = CAST_PTR(ApiRegReq, signal.getDataPtrSend());
req->ref = numberToRef(API_CLUSTERMGR, theFacade.ownId());
req->version = NDB_VERSION;
req->mysql_version = NDB_MYSQL_VERSION_D;
NdbApiSignal nodeFail_signal(numberToRef(API_CLUSTERMGR, getOwnNodeId()));
nodeFail_signal.theVerId_signalNumber = GSN_NODE_FAILREP;
nodeFail_signal.theReceiversBlockNumber = API_CLUSTERMGR;
nodeFail_signal.theTrace = 0;
nodeFail_signal.theLength = NodeFailRep::SignalLengthLong;
NDB_TICKS now = NdbTick_getCurrentTicks();
while(!theStop)
{
/* Sleep 1/5 of minHeartBeatInterval between each check */
const NDB_TICKS before = now;
for (Uint32 i = 0; i<5; i++)
{
NdbSleep_MilliSleep(minHeartBeatInterval/5);
{
/**
* start_poll does lock the trp_client and complete_poll
* releases this lock. This means that this protects
* against concurrent calls to send signals in ArbitMgr.
* We do however need to protect also against concurrent
* close in doStop, so to avoid this problem we need to
* also lock clusterMgrThreadMutex before we start the
* poll.
*/
Guard g(clusterMgrThreadMutex);
start_poll();
do_poll(0);
complete_poll();
}
}
now = NdbTick_getCurrentTicks();
const Uint32 timeSlept = (Uint32)NdbTick_Elapsed(before, now).milliSec();
lock();
if (m_cluster_state == CS_waiting_for_clean_cache &&
theFacade.m_globalDictCache)
{
if (!global_flag_skip_waiting_for_clean_cache)
{
theFacade.m_globalDictCache->lock();
unsigned sz= theFacade.m_globalDictCache->get_size();
theFacade.m_globalDictCache->unlock();
if (sz)
{
unlock();
continue;
}
}
m_cluster_state = CS_waiting_for_first_connect;
}
NodeFailRep * nodeFailRep = CAST_PTR(NodeFailRep,
nodeFail_signal.getDataPtrSend());
nodeFailRep->noOfNodes = 0;
NodeBitmask::clear(nodeFailRep->theAllNodes);
for (int i = 1; i < MAX_NODES; i++)
{
/**
* Send register request (heartbeat) to all available nodes
* at specified timing intervals
*/
const NodeId nodeId = i;
// Check array bounds + don't allow node 0 to be touched
assert(nodeId > 0 && nodeId < MAX_NODES);
Node & cm_node = theNodes[nodeId];
trp_node & theNode = cm_node;
if (!theNode.defined)
continue;
if (theNode.is_connected() == false) {
theFacade.doConnect(nodeId);
continue;
}
if (!theNode.compatible) {
continue;
}
if (nodeId == getOwnNodeId())
{
/**
* Don't send HB to self more than once
* (once needed to avoid weird special cases in e.g ConfigManager)
*/
if (m_sent_API_REGREQ_to_myself)
{
continue;
}
}
cm_node.hbCounter += timeSlept;
if (cm_node.hbCounter >= m_max_api_reg_req_interval ||
cm_node.hbCounter >= cm_node.hbFrequency)
{
/**
* It is now time to send a new Heartbeat
*/
if (cm_node.hbCounter >= cm_node.hbFrequency)
{
cm_node.hbMissed++;
cm_node.hbCounter = 0;
}
if (theNode.m_info.m_type != NodeInfo::DB)
signal.theReceiversBlockNumber = API_CLUSTERMGR;
else
signal.theReceiversBlockNumber = QMGR;
#ifdef DEBUG_REG
ndbout_c("ClusterMgr: Sending API_REGREQ to node %d", (int)nodeId);
#endif
if (nodeId == getOwnNodeId())
{
/* Set flag to ensure we only send once to ourself */
m_sent_API_REGREQ_to_myself = true;
}
raw_sendSignal(&signal, nodeId);
}//if
if (cm_node.hbMissed == 4 && cm_node.hbFrequency > 0)
{
nodeFailRep->noOfNodes++;
NodeBitmask::set(nodeFailRep->theAllNodes, nodeId);
}
}
flush_send_buffers();
unlock();
if (nodeFailRep->noOfNodes)
{
lock();
raw_sendSignal(&nodeFail_signal, getOwnNodeId());
flush_send_buffers();
unlock();
}
}
}
void
ClusterMgr::execNODE_FAILREP(const NdbApiSignal* sig,
const LinearSectionPtr ptr[])
{
const NodeFailRep * rep = CAST_CONSTPTR(NodeFailRep, sig->getDataPtr());
NodeBitmask mask;
if (sig->getLength() == NodeFailRep::SignalLengthLong)
{
mask.assign(NodeBitmask::Size, rep->theAllNodes);
}
else
{
mask.assign(NdbNodeBitmask::Size, rep->theNodes);
}
NdbApiSignal signal(sig->theSendersBlockRef);
signal.theVerId_signalNumber = GSN_NODE_FAILREP;
signal.theReceiversBlockNumber = API_CLUSTERMGR;
signal.theTrace = 0;
signal.theLength = NodeFailRep::SignalLengthLong;
NodeFailRep * copy = CAST_PTR(NodeFailRep, signal.getDataPtrSend());
copy->failNo = 0;
copy->masterNodeId = 0;
copy->noOfNodes = 0;
NodeBitmask::clear(copy->theAllNodes);
for (Uint32 i = mask.find_first(); i != NodeBitmask::NotFound;
i = mask.find_next(i + 1))
{
Node & cm_node = theNodes[i];
trp_node & theNode = cm_node;
bool node_failrep = theNode.m_node_fail_rep;
bool connected = theNode.is_connected();
set_node_dead(theNode);
if (node_failrep == false)
{
theNode.m_node_fail_rep = true;
NodeBitmask::set(copy->theAllNodes, i);
copy->noOfNodes++;
}
if (connected)
{
theFacade.doDisconnect(i);
}
}
recalcMinDbVersion();
if (copy->noOfNodes)
{
theFacade.for_each(this, &signal, 0); // report GSN_NODE_FAILREP
}
if (noOfAliveNodes == 0)
{
NdbApiSignal signal(numberToRef(API_CLUSTERMGR, getOwnNodeId()));
signal.theVerId_signalNumber = GSN_NF_COMPLETEREP;
signal.theReceiversBlockNumber = 0;
signal.theTrace = 0;
signal.theLength = NFCompleteRep::SignalLength;
NFCompleteRep * rep = CAST_PTR(NFCompleteRep, signal.getDataPtrSend());
rep->blockNo =0;
rep->nodeId = getOwnNodeId();
rep->unused = 0;
rep->from = __LINE__;
for (Uint32 i = 1; i < MAX_NODES; i++)
{
trp_node& theNode = theNodes[i];
if (theNode.defined && theNode.nfCompleteRep == false)
{
rep->failedNodeId = i;
execNF_COMPLETEREP(&signal, 0);
}
}
}
}
void Cmvmi::execOPEN_COMREQ(Signal* signal)
{
// Connect to the specifed NDB node, only QMGR allowed communication
// so far with the node
const BlockReference userRef = signal->theData[0];
Uint32 tStartingNode = signal->theData[1];
Uint32 tData2 = signal->theData[2];
jamEntry();
const Uint32 len = signal->getLength();
if(len == 2)
{
#ifdef ERROR_INSERT
if (! ((ERROR_INSERTED(9000) || ERROR_INSERTED(9002))
&& c_error_9000_nodes_mask.get(tStartingNode)))
#endif
{
if (globalData.theStartLevel != NodeState::SL_STARTED &&
(getNodeInfo(tStartingNode).m_type != NodeInfo::DB &&
getNodeInfo(tStartingNode).m_type != NodeInfo::MGM))
{
jam();
goto done;
}
globalTransporterRegistry.do_connect(tStartingNode);
globalTransporterRegistry.setIOState(tStartingNode, HaltIO);
//-----------------------------------------------------
// Report that the connection to the node is opened
//-----------------------------------------------------
signal->theData[0] = NDB_LE_CommunicationOpened;
signal->theData[1] = tStartingNode;
sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 2, JBB);
//-----------------------------------------------------
}
} else {
for(unsigned int i = 1; i < MAX_NODES; i++ )
{
jam();
if (i != getOwnNodeId() && getNodeInfo(i).m_type == tData2)
{
jam();
#ifdef ERROR_INSERT
if ((ERROR_INSERTED(9000) || ERROR_INSERTED(9002))
&& c_error_9000_nodes_mask.get(i))
continue;
#endif
globalTransporterRegistry.do_connect(i);
globalTransporterRegistry.setIOState(i, HaltIO);
signal->theData[0] = NDB_LE_CommunicationOpened;
signal->theData[1] = i;
sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 2, JBB);
}
}
}
done:
if (userRef != 0) {
jam();
signal->theData[0] = tStartingNode;
signal->theData[1] = tData2;
sendSignal(userRef, GSN_OPEN_COMCONF, signal, len - 1,JBA);
}
}
