inline void SignalCounter::clearWaitingFor(Uint32 nodeId) { if(m_nodes.get(nodeId) && m_count > 0){ m_count--; m_nodes.clear(nodeId); return; } ErrorReporter::handleAssert("SignalCounter::clear", __FILE__, __LINE__); }
inline void SignalCounter::setWaitingFor(Uint32 nodeId) { if(!m_nodes.get(nodeId)){ m_nodes.set(nodeId); m_count++; return; } ErrorReporter::handleAssert("SignalCounter::set", __FILE__, __LINE__); }
inline SignalCounter& SignalCounter::operator=(Uint32 count){ m_count = count; m_nodes.clear(); return * this; }
inline const char * SignalCounter::getText() const { static char buf[255]; static char nodes[NdbNodeBitmask::TextLength+1]; BaseString::snprintf(buf, sizeof(buf), "[SignalCounter: m_count=%d %s]", m_count, m_nodes.getText(nodes)); return buf; }
int NdbRestarter::checkClusterAlive(const int * deadnodes, int num_nodes) { if (getStatus() != 0) return -1; NdbNodeBitmask mask; for (int i = 0; i<num_nodes; i++) mask.set(deadnodes[i]); for (unsigned n = 0; n < ndbNodes.size(); n++) { if (mask.get(ndbNodes[n].node_id)) continue; if (ndbNodes[n].node_status != NDB_MGM_NODE_STATUS_STARTED) return ndbNodes[n].node_id; } return 0; }
int main(int argc, char** argv){ NDB_INIT(argv[0]); ndb_opt_set_usage_funcs(short_usage_sub, usage); load_defaults("my",load_default_groups,&argc,&argv); #ifndef DBUG_OFF opt_debug= "d:t:O,/tmp/ndb_waiter.trace"; #endif #ifndef _WIN32 // Catching signal to allow testing of EINTR safeness // with "while killall -USR1 ndbwaiter; do true; done" signal(SIGUSR1, catch_signal); #endif if (handle_options(&argc, &argv, my_long_options, ndb_std_get_one_option)) return NDBT_ProgramExit(NDBT_WRONGARGS); const char* connect_string = argv[0]; if (connect_string == 0) connect_string = opt_ndb_connectstring; enum ndb_mgm_node_status wait_status; if (_no_contact) { wait_status= NDB_MGM_NODE_STATUS_NO_CONTACT; } else if (_not_started) { wait_status= NDB_MGM_NODE_STATUS_NOT_STARTED; } else if (_single_user) { wait_status= NDB_MGM_NODE_STATUS_SINGLEUSER; } else { wait_status= NDB_MGM_NODE_STATUS_STARTED; } if (_nowait_nodes) { int res = parse_mask(_nowait_nodes, nowait_nodes_bitmask); if(res == -2 || (res > 0 && nowait_nodes_bitmask.get(0))) { ndbout_c("Invalid nodeid specified in nowait-nodes: %s", _nowait_nodes); exit(-1); } else if (res < 0) { ndbout_c("Unable to parse nowait-nodes argument: %s", _nowait_nodes); exit(-1); } } if (_wait_nodes) { if (_nowait_nodes) { ndbout_c("Can not set both wait-nodes and nowait-nodes."); exit(-1); } int res = parse_mask(_wait_nodes, nowait_nodes_bitmask); if (res == -2 || (res > 0 && nowait_nodes_bitmask.get(0))) { ndbout_c("Invalid nodeid specified in wait-nodes: %s", _wait_nodes); exit(-1); } else if (res < 0) { ndbout_c("Unable to parse wait-nodes argument: %s", _wait_nodes); exit(-1); } // Don't wait for any other nodes than the ones we have set explicitly nowait_nodes_bitmask.bitNOT(); } if (waitClusterStatus(connect_string, wait_status) != 0) return NDBT_ProgramExit(NDBT_FAILED); return NDBT_ProgramExit(NDBT_OK); }
int getStatus(){ int retries = 0; struct ndb_mgm_cluster_state * status; struct ndb_mgm_node_state * node; ndbNodes.clear(); while(retries < 10){ status = ndb_mgm_get_status(handle); if (status == NULL){ ndbout << "status==NULL, retries="<<retries<<endl; MGMERR(handle); retries++; ndb_mgm_disconnect(handle); if (ndb_mgm_connect(handle,0,0,1)) { MGMERR(handle); g_err << "Reconnect failed" << endl; break; } continue; } int count = status->no_of_nodes; for (int i = 0; i < count; i++){ node = &status->node_states[i]; switch(node->node_type){ case NDB_MGM_NODE_TYPE_NDB: if (!nowait_nodes_bitmask.get(node->node_id)) ndbNodes.push_back(*node); break; case NDB_MGM_NODE_TYPE_MGM: /* Don't care about MGM nodes */ break; case NDB_MGM_NODE_TYPE_API: /* Don't care about API nodes */ break; default: if(node->node_status == NDB_MGM_NODE_STATUS_UNKNOWN || node->node_status == NDB_MGM_NODE_STATUS_NO_CONTACT){ retries++; ndbNodes.clear(); free(status); status = NULL; count = 0; ndbout << "kalle"<< endl; break; } abort(); break; } } if(status == 0){ ndbout << "status == 0" << endl; continue; } free(status); return 0; } return -1; }
inline void SignalCounter::clearWaitingFor(){ m_count = 0; m_nodes.clear(); }
inline bool SignalCounter::isWaitingFor(Uint32 nodeId) const { return m_nodes.get(nodeId); }