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);
}