int runBug24717(NDBT_Context* ctx, NDBT_Step* step){
int result = NDBT_OK;
int loops = ctx->getNumLoops();
int records = ctx->getNumRecords();
NdbRestarter restarter;
Ndb* pNdb = GETNDB(step);
HugoTransactions hugoTrans(*ctx->getTab());
int dump[] = { 9002, 0 } ;
Uint32 ownNode = refToNode(pNdb->getReference());
dump[1] = ownNode;
for (; loops; loops --)
{
int nodeId = restarter.getRandomNotMasterNodeId(rand());
restarter.restartOneDbNode(nodeId, false, true, true);
restarter.waitNodesNoStart(&nodeId, 1);
if (restarter.dumpStateOneNode(nodeId, dump, 2))
return NDBT_FAILED;
restarter.startNodes(&nodeId, 1);
do {
for (Uint32 i = 0; i < 100; i++)
{
hugoTrans.pkReadRecords(pNdb, 100, 1, NdbOperation::LM_CommittedRead);
}
} while (restarter.waitClusterStarted(5) != 0);
}
return NDBT_OK;
}
void getTextBackupAborted(QQQQ) {
BaseString::snprintf(m_text, m_text_len,
"Backup %d started from %d has been aborted. Error: %d",
theData[2],
refToNode(theData[1]),
theData[3]);
}
bool
NdbInfoScanOperation::init(Uint32 id)
{
DBUG_ENTER("NdbInfoScanoperation::init");
if (m_state != Undefined)
DBUG_RETURN(false);
m_signal_sender = new SignalSender(m_connection);
if (!m_signal_sender)
DBUG_RETURN(false);
m_transid0 = id;
m_transid1 = m_table->getTableId();
m_result_ref = m_signal_sender->getOwnRef();
for (unsigned i = 0; i < m_table->columns(); i++)
m_recAttrs.push_back(NULL);
/*
Build a bitmask of nodes that will be scanned if
connected and have been API_REGCONFed. Don't include
own node since it will always be "connected"
*/
for (Uint32 i = 1; i < MAX_NDB_NODES; i++)
m_impl.m_nodes_to_scan.set(i);
m_impl.m_nodes_to_scan.clear(refToNode(m_result_ref));
m_state = Initial;
DBUG_RETURN(true);
}
bool
printPREPFAILREQREF(FILE * output,
const Uint32 * theData,
Uint32 len,
Uint16 receiverBlockNo){
PrepFailReqRef * cc = (PrepFailReqRef*)theData;
fprintf(output, " xxxBlockRef = (%d, %d) failNo = %d noOfNodes = %d\n",
refToBlock(cc->xxxBlockRef), refToNode(cc->xxxBlockRef),
cc->failNo, cc->noOfNodes);
int hits = 0;
fprintf(output, " Nodes: ");
for(int i = 0; i<MAX_NODES; i++){
if(NodeBitmask::get(cc->theNodes, i)){
hits++;
fprintf(output, " %d", i);
}
if(hits == 16){
fprintf(output, "\n Nodes: ");
hits = 0;
}
}
if(hits != 0)
fprintf(output, "\n");
return true;
}
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
ClusterMgr::execAPI_REGREF(const Uint32 * theData) {
ApiRegRef * ref = (ApiRegRef*)theData;
const NodeId nodeId = refToNode(ref->ref);
assert(nodeId > 0 && nodeId < MAX_NODES);
Node & cm_node = theNodes[nodeId];
trp_node & node = cm_node;
assert(node.is_connected() == true);
assert(node.defined == true);
/* Only DB nodes will send API_REGREF */
assert(node.m_info.getType() == NodeInfo::DB);
node.compatible = false;
set_node_alive(node, false);
node.m_state = NodeState::SL_NOTHING;
node.m_info.m_version = ref->version;
switch(ref->errorCode) {
case ApiRegRef::WrongType:
ndbout_c("Node %d reports that this node should be a NDB node", nodeId);
abort();
case ApiRegRef::UnsupportedVersion:
default:
break;
}
}
void
ClusterMgr::execAPI_REGREF(const Uint32 * theData){
ApiRegRef * ref = (ApiRegRef*)theData;
const NodeId nodeId = refToNode(ref->ref);
assert(nodeId > 0 && nodeId < MAX_NODES);
Node & node = theNodes[nodeId];
assert(node.connected == true);
assert(node.defined == true);
node.compatible = false;
set_node_alive(node, false);
node.m_state = NodeState::SL_NOTHING;
node.m_info.m_version = ref->version;
switch(ref->errorCode){
case ApiRegRef::WrongType:
ndbout_c("Node %d reports that this node should be a NDB node", nodeId);
abort();
case ApiRegRef::UnsupportedVersion:
default:
break;
}
waitForHBFromNodes.clear(nodeId);
if(waitForHBFromNodes.isclear())
NdbCondition_Signal(waitForHBCond);
}
void Ndb::connected(Uint32 ref)
{
// cluster connect, a_node == own reference
theMyRef= ref;
Uint32 tmpTheNode= refToNode(ref);
Uint64 tBlockNo= refToBlock(ref);
if (theNdbBlockNumber >= 0){
assert(theMyRef == numberToRef(theNdbBlockNumber, tmpTheNode));
}
Uint32 cnt =
theImpl->m_ndb_cluster_connection.get_db_nodes(theImpl->theDBnodes);
theImpl->theNoOfDBnodes = cnt;
theFirstTransId += ((Uint64)tBlockNo << 52)+
((Uint64)tmpTheNode << 40);
// assert(0);
DBUG_PRINT("info",("connected with ref=%x, id=%d, no_db_nodes=%d, first_trans_id: 0x%lx",
theMyRef,
tmpTheNode,
theImpl->theNoOfDBnodes,
(long) theFirstTransId));
theCommitAckSignal = new NdbApiSignal(theMyRef);
theDictionary->m_receiver.m_reference= theMyRef;
theNode= tmpTheNode; // flag that Ndb object is initialized
}
inline
NodeReceiverGroup&
NodeReceiverGroup::operator=(BlockReference blockRef){
m_nodes.clear();
m_block = refToBlock(blockRef);
m_nodes.set(refToNode(blockRef));
return * this;
}
void getTextBackupCompleted(QQQQ) {
BaseString::snprintf(m_text, m_text_len,
"Backup %u started from node %u completed."
" StartGCP: %u StopGCP: %u"
" #Records: %u #LogRecords: %u"
" Data: %u bytes Log: %u bytes",
theData[2], refToNode(theData[1]),
theData[3], theData[4], theData[6], theData[8],
theData[5], theData[7]);
}
bool
printSTART_LCP_CONF(FILE * output, const Uint32 * theData,
Uint32 len, Uint16 receiverBlockNo){
const StartLcpConf * const sig = (StartLcpConf *) theData;
fprintf(output, " Sender: %d LcpId: %d\n",
refToNode(sig->senderRef), sig->lcpId);
return true;
}
/**
* execROUTE_ORD
* Allows other blocks to route signals as if they
* came from TRPMAN
* Useful in ndbmtd for synchronising signals w.r.t
* external signals received from other nodes which
* arrive from the same thread that runs TRPMAN
*/
void
Trpman::execROUTE_ORD(Signal* signal)
{
jamEntry();
if (!assembleFragments(signal))
{
jam();
return;
}
SectionHandle handle(this, signal);
RouteOrd* ord = (RouteOrd*)signal->getDataPtr();
Uint32 dstRef = ord->dstRef;
Uint32 srcRef = ord->srcRef;
Uint32 gsn = ord->gsn;
/* ord->cnt ignored */
Uint32 nodeId = refToNode(dstRef);
if (likely((nodeId == 0) ||
getNodeInfo(nodeId).m_connected))
{
jam();
Uint32 secCount = handle.m_cnt;
ndbrequire(secCount >= 1 && secCount <= 3);
jamLine(secCount);
/**
* Put section 0 in signal->theData
*/
Uint32 sigLen = handle.m_ptr[0].sz;
ndbrequire(sigLen <= 25);
copy(signal->theData, handle.m_ptr[0]);
SegmentedSectionPtr save = handle.m_ptr[0];
for (Uint32 i = 0; i < secCount - 1; i++)
handle.m_ptr[i] = handle.m_ptr[i+1];
handle.m_cnt--;
sendSignal(dstRef, gsn, signal, sigLen, JBB, &handle);
handle.m_cnt = 1;
handle.m_ptr[0] = save;
releaseSections(handle);
return ;
}
releaseSections(handle);
warningEvent("Unable to route GSN: %d from %x to %x",
gsn, srcRef, dstRef);
}
void
DblqhProxy::execEMPTY_LCP_REQ(Signal* signal)
{
jam();
CRASH_INSERTION(5008);
EmptyLcpReq * const req = (EmptyLcpReq*)&signal->theData[0];
Uint32 nodeId = refToNode(req->senderRef);
c_lcpRecord.m_empty_lcp_req.set(nodeId);
checkSendEMPTY_LCP_CONF(signal);
}
// 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);
}
}
// 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
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);
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;
conf->apiHeartbeatFrequency = cm_node.hbFrequency;
conf->minDbVersion= 0;
conf->nodeState= node.m_state;
node.set_confirmed(true);
if (safe_sendSignal(&signal, nodeId) != 0)
node.set_confirmed(false);
}
void
ClusterMgr::execAPI_REGCONF(const Uint32 * theData){
const ApiRegConf * const apiRegConf = (ApiRegConf *)&theData[0];
const NodeId nodeId = refToNode(apiRegConf->qmgrRef);
#ifdef DEBUG_REG
ndbout_c("ClusterMgr: Recd API_REGCONF from node %d", nodeId);
#endif
assert(nodeId > 0 && nodeId < MAX_NODES);
Node & node = theNodes[nodeId];
assert(node.defined == true);
assert(node.connected == true);
if(node.m_info.m_version != apiRegConf->version){
node.m_info.m_version = apiRegConf->version;
if(theNodes[theFacade.ownId()].m_info.m_type == NodeInfo::MGM)
node.compatible = ndbCompatible_mgmt_ndb(NDB_VERSION,
node.m_info.m_version);
else
node.compatible = ndbCompatible_api_ndb(NDB_VERSION,
node.m_info.m_version);
}
node.m_api_reg_conf = true;
node.m_state = apiRegConf->nodeState;
if (node.compatible && (node.m_state.startLevel == NodeState::SL_STARTED ||
node.m_state.getSingleUserMode())){
set_node_alive(node, true);
} else {
set_node_alive(node, false);
}//if
node.m_info.m_heartbeat_cnt = 0;
node.hbCounter = 0;
if(waitingForHB)
{
waitForHBFromNodes.clear(nodeId);
if(waitForHBFromNodes.isclear())
{
waitingForHB= false;
NdbCondition_Broadcast(waitForHBCond);
}
}
node.hbFrequency = (apiRegConf->apiHeartbeatFrequency * 10) - 50;
}
bool
printAPI_VERSION_CONF(FILE * output,
const Uint32 * theData,
Uint32 len,
Uint16 recBlockNo){
ApiVersionConf * sig = (ApiVersionConf *)&theData[0];
fprintf(output,
" senderRef: (node: %d, block: %d), nodeId: %d\n" \
" version: %d, mysql_version: %d, inet_addr: %d\n",
refToNode(sig->senderRef), refToBlock(sig->senderRef),
sig->nodeId, sig->version, sig->mysql_version, sig->inet_addr);
return true;
}
void Cmvmi::execEVENT_REP(Signal* signal)
{
//-----------------------------------------------------------------------
// This message is sent to report any types of events in NDB.
// Based on the log level they will be either ignored or
// reported. Currently they are printed, but they will be
// transferred to the management server for further distribution
// to the graphical management interface.
//-----------------------------------------------------------------------
EventReport * const eventReport = (EventReport *)&signal->theData[0];
Ndb_logevent_type eventType = eventReport->getEventType();
Uint32 nodeId= eventReport->getNodeId();
if (nodeId == 0)
{
nodeId= refToNode(signal->getSendersBlockRef());
eventReport->setNodeId(nodeId);
}
jamEntry();
/**
* If entry is not found
*/
Uint32 threshold;
LogLevel::EventCategory eventCategory;
Logger::LoggerLevel severity;
EventLoggerBase::EventTextFunction textF;
if (EventLoggerBase::event_lookup(eventType,eventCategory,threshold,severity,textF))
return;
SubscriberPtr ptr;
for(subscribers.first(ptr); ptr.i != RNIL; subscribers.next(ptr)){
if(ptr.p->logLevel.getLogLevel(eventCategory) < threshold){
continue;
}
sendSignal(ptr.p->blockRef, GSN_EVENT_REP, signal, signal->length(), JBB);
}
if(clogLevel.getLogLevel(eventCategory) < threshold){
return;
}
// Print the event info
g_eventLogger.log(eventReport->getEventType(), signal->theData);
return;
}//execEVENT_REP()
void
Cmvmi::cancelSubscription(NodeId nodeId){
SubscriberPtr ptr;
subscribers.first(ptr);
while(ptr.i != RNIL){
Uint32 i = ptr.i;
BlockReference blockRef = ptr.p->blockRef;
subscribers.next(ptr);
if(refToNode(blockRef) == nodeId){
subscribers.release(i);
}
}
}
bool
printSTART_LCP_REQ(FILE * output, const Uint32 * theData,
Uint32 len, Uint16 receiverBlockNo){
const StartLcpReq * const sig = (StartLcpReq *) theData;
char buf1[8*_NDB_NODE_BITMASK_SIZE+1];
char buf2[8*_NDB_NODE_BITMASK_SIZE+1];
fprintf(output,
" Sender: %d LcpId: %d\n"
" ParticipatingDIH = %s\n"
" ParticipatingLQH = %s\n",
refToNode(sig->senderRef), sig->lcpId,
sig->participatingDIH.getText(buf1),
sig->participatingLQH.getText(buf2));
return true;
}
void
execute(void* callbackObj,
SignalHeader * const header, Uint8 prio, Uint32 * const theData,
LinearSectionPtr ptr[3]){
const NodeId nodeId = refToNode(header->theSendersBlockRef);
ndbout << "Recieved prio " << (int)prio << " signal from node: "
<< nodeId
<< " gsn = " << header->theVerId_signalNumber << endl;
checkData(header, prio, theData, ptr);
ndbout << " Data is ok!\n" << endl;
signalReceived[nodeId]++;
if(prio == 0)
sendSignalTo(nodeId, 1);
else
tReg->setPerformState(nodeId, PerformDisconnect);
}
bool
printSTART_REC_REQ(FILE * output,
const Uint32 * theData,
Uint32 len,
Uint16 recBlockNo){
StartRecReq * sig = (StartRecReq *) theData;
fprintf(output, " receivingNodeId: %d senderRef: (%d, %d)\n",
sig->receivingNodeId,
refToNode(sig->senderRef),
refToBlock(sig->senderRef));
fprintf(output, " keepGci: %d lastCompletedGci: %d newestGci: %d\n",
sig->keepGci,
sig->lastCompletedGci,
sig->newestGci);
return true;
}
void
Dbtup::execDROP_TRIG_REQ(Signal* signal)
{
jamEntry();
BlockReference senderRef = signal->getSendersBlockRef();
const DropTrigReq reqCopy = *(const DropTrigReq*)signal->getDataPtr();
const DropTrigReq* const req = &reqCopy;
// Find table
TablerecPtr tabPtr;
tabPtr.i = req->getTableId();
ptrCheckGuard(tabPtr, cnoOfTablerec, tablerec);
// Drop trigger
Uint32 r = dropTrigger(tabPtr.p, req, refToBlock(senderRef));
if (r == 0){
// Send conf
DropTrigConf* const conf = (DropTrigConf*)signal->getDataPtrSend();
conf->setUserRef(senderRef);
conf->setConnectionPtr(req->getConnectionPtr());
conf->setRequestType(req->getRequestType());
conf->setTableId(req->getTableId());
conf->setIndexId(req->getIndexId());
conf->setTriggerId(req->getTriggerId());
sendSignal(senderRef, GSN_DROP_TRIG_CONF,
signal, DropTrigConf::SignalLength, JBB);
} else {
// Send ref
DropTrigRef* const ref = (DropTrigRef*)signal->getDataPtrSend();
ref->setUserRef(senderRef);
ref->setConnectionPtr(req->getConnectionPtr());
ref->setRequestType(req->getRequestType());
ref->setTableId(req->getTableId());
ref->setIndexId(req->getIndexId());
ref->setTriggerId(req->getTriggerId());
ref->setErrorCode((DropTrigRef::ErrorCode)r);
ref->setErrorLine(__LINE__);
ref->setErrorNode(refToNode(reference()));
sendSignal(senderRef, GSN_DROP_TRIG_REF,
signal, DropTrigRef::SignalLength, JBB);
}
}//Dbtup::DROP_TRIG_REQ()
bool
printFIRE_TRIG_ORD(FILE * output, const Uint32 * theData, Uint32 len,
Uint16 receiverBlockNo)
{
const FireTrigOrd * const sig = (FireTrigOrd *) theData;
fprintf(output, " TriggerId: %d TriggerEvent: %s\n",
sig->getTriggerId(),
trigEvent(sig->getTriggerEvent()));
fprintf(output, " UserRef: (%d, %d) User data: %x\n",
refToNode(sig->getUserRef()),
refToBlock(sig->getUserRef()),
sig->getConnectionPtr());
fprintf(output, " Signal: PK=%d BEFORE=%d AFTER=%d\n",
sig->getNoOfPrimaryKeyWords(),
sig->getNoOfBeforeValueWords(),
sig->getNoOfAfterValueWords());
return true;
}
NdbApiSignal *
SignalQueue::waitFor(int gsn, NodeId nodeid, Uint32 timeout) {
Guard g(m_mutex);
if(m_signalQueueHead == NULL)
NdbCondition_WaitTimeout(m_cond, m_mutex, timeout);
if(m_signalQueueHead == NULL)
return NULL;
if(gsn != 0 &&
m_signalQueueHead->signal->readSignalNumber() != gsn)
return NULL;
if(nodeid != 0 &&
refToNode(m_signalQueueHead->signal->theSendersBlockRef) != nodeid)
return NULL;
return pop();
}
bool defragment(SimpleSignal* sig) {
if (!sig->isFragmented())
return true;
Uint32 fragId = sig->getFragmentId();
NodeId nodeId = refToNode(sig->header.theSendersBlockRef);
DefragBuffer* dbuf;
if(sig->isFirstFragment()){
// Make sure buffer does not exist
if (find_buffer(nodeId, fragId))
abort();
dbuf = new DefragBuffer(nodeId, fragId);
m_buffers.push_back(dbuf);
} else {
dbuf = find_buffer(nodeId, fragId);
if (dbuf == NULL)
abort();
}
if (dbuf->m_buffer.append(sig->ptr[0].p, sig->ptr[0].sz * sizeof(Uint32)))
abort(); // OOM
if (!sig->isLastFragment())
return false;
// Copy defragmented data into signal...
int length = dbuf->m_buffer.length();
delete[] sig->ptr[0].p;
sig->ptr[0].sz = (length+3)/4;
sig->ptr[0].p = new Uint32[sig->ptr[0].sz];
memcpy(sig->ptr[0].p, dbuf->m_buffer.get_data(), length);
// erase the buffer data
erase_buffer(dbuf);
return true;
}
void Dbtup::bufferTRANSID_AI(Signal* signal, BlockReference aRef,
Uint32 Tlen)
{
if (Tlen == 3)
return;
Uint32 hostId= refToNode(aRef);
Uint32 Theader= ((refToBlock(aRef) << 16)+(Tlen-3));
ndbrequire(hostId < MAX_NODES);
Uint32 TpacketLen= hostBuffer[hostId].packetLenTA;
Uint32 TnoOfPackets= hostBuffer[hostId].noOfPacketsTA;
Uint32 sig0= signal->theData[0];
Uint32 sig1= signal->theData[1];
Uint32 sig2= signal->theData[2];
BlockReference TBref= numberToRef(API_PACKED, hostId);
if ((Tlen + TpacketLen + 1) <= 25) {
// ----------------------------------------------------------------
// There is still space in the buffer. We will copy it into the
// buffer.
// ----------------------------------------------------------------
jam();
updatePackedList(signal, hostId);
} else if (false && TnoOfPackets == 1) {
// ----------------------------------------------------------------
// The buffer is full and there was only one packet buffered. We
// will send this as a normal signal.
// ----------------------------------------------------------------
Uint32 TnewRef= numberToRef((hostBuffer[hostId].packetBufferTA[0] >> 16),
hostId);
MEMCOPY_NO_WORDS(&signal->theData[0],
&hostBuffer[hostId].packetBufferTA[1],
TpacketLen - 1);
sendSignal(TnewRef, GSN_TRANSID_AI, signal, (TpacketLen - 1), JBB);
TpacketLen= 0;
TnoOfPackets= 0;
} else {
void
execute(void* callbackObj, SignalHeader * const header, Uint8 prio,
Uint32 * const theData,
LinearSectionPtr ptr[3]){
const NodeId nodeId = refToNode(header->theSendersBlockRef);
if(isClient){
allPhases[currentPhase].noOfSignalReceived++;
} else {
int sleepTime = 10;
if(theData[0] != signalsEchoed){
ndbout << "Missing signal theData[0] = " << theData[0]
<< " signalsEchoed = " << signalsEchoed << endl;
ndbout << (* header) << endl;
abort();
}
while(tReg->prepareSend(header, prio, theData, nodeId, ptr) != SEND_OK){
ndbout << "Failed to echo " << theData[0] << endl;
NdbSleep_MilliSleep(sleepTime);
// sleepTime += 10;
}
signalsEchoed++;
}
}
int
main(void){
srand(NdbTick_CurrentMillisecond());
#if 0
for(int i = 0; i<100; i++)
ndbout_c("randRange(0, 3) = %d", randRange(0, 3));
return 0;
#endif
SignalSender ss;
ndbout << "Connecting...";
if(!ss.connect(30)){
ndbout << "failed" << endl << "Exiting" << endl;
return 0;
}
ndbout << "done" << endl;
ndbout_c("Connected as block=%d node=%d",
refToBlock(ss.getOwnRef()), refToNode(ss.getOwnRef()));
Uint32 data[25];
Uint32 sec0[70];
Uint32 sec1[123];
Uint32 sec2[10];
data[0] = ss.getOwnRef();
data[1] = 1;
data[2] = 76;
data[3] = 1;
data[4] = 1;
data[5] = 70;
data[6] = 123;
data[7] = 10;
const Uint32 theDataLen = 18;
for(Uint32 i = 0; i<70; i++)
sec0[i] = i;
for(Uint32 i = 0; i<123; i++)
sec1[i] = 70+i;
for(Uint32 i = 0; i<10; i++)
sec2[i] = (i + 1)*(i + 1);
SimpleSignal signal1;
signal1.set(ss, 0, CMVMI, GSN_TESTSIG, theDataLen + 2);
signal1.header.m_noOfSections = 1;
signal1.header.m_fragmentInfo = 1;
memcpy(&signal1.theData[0], data, 4 * theDataLen );
signal1.theData[theDataLen + 0] = 0;
signal1.theData[theDataLen + 1] = 7; // FragmentId
signal1.ptr[0].sz = 60;
signal1.ptr[0].p = &sec0[0];
SimpleSignal signal2;
Uint32 idx = 0;
memcpy(&signal2.theData[0], data, 4 * theDataLen );
signal2.theData[theDataLen + idx] = 0; idx++;
signal2.theData[theDataLen + idx] = 1; idx++;
//signal2.theData[theDataLen + idx] = 2; idx++;
signal2.theData[theDataLen + idx] = 7; idx++; // FragmentId
signal2.set(ss, 0, CMVMI, GSN_TESTSIG, theDataLen + idx);
signal2.header.m_fragmentInfo = 3;
signal2.header.m_noOfSections = idx - 1;
signal2.ptr[0].sz = 10;
signal2.ptr[0].p = &sec0[60];
signal2.ptr[1].sz = 123;
signal2.ptr[1].p = &sec1[0];
signal2.ptr[2].sz = 10;
signal2.ptr[2].p = &sec2[0];
char * buf;
while((buf = readline("Enter command: "))){
add_history(buf);
data[1] = atoi(buf);
if(strcmp(buf, "r") == 0){
SimpleSignal * ret1 = ss.waitFor();
(* ret1).print();
delete ret1;
continue;
}
if(strcmp(buf, "a") == 0){
runTest(ss, 10, true);
print_help();
continue;
}
if(strcmp(buf, "b") == 0){
runTest(ss, 100, false);
print_help();
continue;
}
if(strcmp(buf, "c") == 0){
runTest(ss, 1000000, false);
print_help();
continue;
}
if(data[1] >= 1 && data[1] <= 12){
Uint32 nodeId = ss.getAliveNode();
ndbout_c("Sending 2 fragmented to node %d", nodeId);
ss.sendSignal(nodeId, &signal1);
ss.sendSignal(nodeId, &signal2);
if(data[1] >= 5){
continue;
}
ndbout_c("Waiting for signal from %d", nodeId);
SimpleSignal * ret1 = ss.waitFor((Uint16)nodeId);
(* ret1).print();
Uint32 count = ret1->theData[4] - 1;
delete ret1;
while(count > 0){
ndbout << "Waiting for " << count << " signals... ";
SimpleSignal * ret1 = ss.waitFor();
ndbout_c("received from node %d",
refToNode(ret1->header.theSendersBlockRef));
(* ret1).print();
delete ret1;
count--;
}
} else if (data[1] == 13) {
const Uint32 count = 3500;
const Uint32 loop = 1000;
signal1.set(ss, 0, CMVMI, GSN_TESTSIG, 25);
signal1.header.m_fragmentInfo = 0;
signal1.header.m_noOfSections = 0;
signal1.theData[1] = 14;
signal1.theData[3] = 0; // Print
signal1.theData[8] = count;
signal1.theData[9] = loop;
Uint32 nodeId = ss.getAliveNode();
ndbout_c("Sending 25 len signal to node %d", nodeId);
ss.sendSignal(nodeId, &signal1);
Uint32 total;
{
SimpleSignal * ret1 = ss.waitFor((Uint16)nodeId);
ndbout_c("received from node %d",
refToNode(ret1->header.theSendersBlockRef));
total = ret1->theData[10] - 1;
delete ret1;
}
do {
ndbout << "Waiting for " << total << " signals... " << flush;
SimpleSignal * ret1 = ss.waitFor((Uint16)nodeId);
ndbout_c("received from node %d",
refToNode(ret1->header.theSendersBlockRef));
delete ret1;
total --;
} while(total > 0);
} else {
print_help();
}
}
ndbout << "Exiting" << endl;
};