int
Ndb_cluster_connection::wait_until_ready(int timeout,
int timeout_after_first_alive)
{
DBUG_ENTER("Ndb_cluster_connection::wait_until_ready");
TransporterFacade *tp = TransporterFacade::instance();
if (tp == 0)
{
DBUG_RETURN(-1);
}
if (tp->ownId() == 0)
{
DBUG_RETURN(-1);
}
int secondsCounter = 0;
int milliCounter = 0;
int noChecksSinceFirstAliveFound = 0;
do {
unsigned int foundAliveNode = 0;
tp->lock_mutex();
for(unsigned i= 0; i < no_db_nodes(); i++)
{
//************************************************
// If any node is answering, ndb is answering
//************************************************
if (tp->get_node_alive(m_impl.m_all_nodes[i].id) != 0) {
foundAliveNode++;
}
}
tp->unlock_mutex();
if (foundAliveNode == no_db_nodes())
{
DBUG_RETURN(0);
}
else if (foundAliveNode > 0)
{
noChecksSinceFirstAliveFound++;
// 100 ms delay -> 10*
if (noChecksSinceFirstAliveFound > 10*timeout_after_first_alive)
DBUG_RETURN(1);
}
else if (secondsCounter >= timeout)
{ // no alive nodes and timed out
DBUG_RETURN(-1);
}
NdbSleep_MilliSleep(100);
milliCounter += 100;
if (milliCounter >= 1000) {
secondsCounter++;
milliCounter = 0;
}//if
} while (1);
}
unsigned
Ndb_cluster_connection::max_nodegroup()
{
TransporterFacade *tp = m_impl.m_transporter_facade;
if (tp == 0 || tp->ownId() == 0)
return 0;
Bitmask<MAX_NDB_NODES> ng;
tp->lock_mutex();
for(unsigned i= 0; i < no_db_nodes(); i++)
{
//************************************************
// If any node is answering, ndb is answering
//************************************************
trp_node n = tp->theClusterMgr->getNodeInfo(m_impl.m_all_nodes[i].id);
if (n.is_confirmed() && n.m_state.nodeGroup <= MAX_NDB_NODES)
ng.set(n.m_state.nodeGroup);
}
tp->unlock_mutex();
if (ng.isclear())
return 0;
Uint32 n = ng.find_first();
Uint32 m;
do
{
m = n;
} while ((n = ng.find(n+1)) != ng.NotFound);
return m;
}
void
Ndb_cluster_connection_impl::init_get_next_node
(Ndb_cluster_connection_node_iter &iter)
{
if (iter.scan_state != (Uint8)~0)
iter.cur_pos= iter.scan_state;
if (iter.cur_pos >= no_db_nodes())
iter.cur_pos= 0;
iter.init_pos= iter.cur_pos;
iter.scan_state= 0;
// fprintf(stderr,"[init %d]",iter.init_pos);
return;
}
void
Ndb_cluster_connection_impl::do_test()
{
Ndb_cluster_connection_node_iter iter;
int n= no_db_nodes()+5;
Uint32 *nodes= new Uint32[n+1];
for (int g= 0; g < n; g++)
{
for (int h= 0; h < n; h++)
{
Uint32 id;
Ndb_cluster_connection_node_iter iter2;
{
for (int j= 0; j < g; j++)
{
nodes[j]= get_next_node(iter2);
}
}
for (int i= 0; i < n; i++)
{
init_get_next_node(iter);
fprintf(stderr, "%d dead:(", g);
id= 0;
while (id == 0)
{
if ((id= get_next_node(iter)) == 0)
break;
for (int j= 0; j < g; j++)
{
if (nodes[j] == id)
{
fprintf(stderr, " %d", id);
id= 0;
break;
}
}
}
fprintf(stderr, ")");
if (id == 0)
{
break;
}
fprintf(stderr, " %d\n", id);
}
fprintf(stderr, "\n");
}
}
delete [] nodes;
}
Uint32
Ndb_cluster_connection_impl::get_next_node(Ndb_cluster_connection_node_iter &iter)
{
Uint32 cur_pos= iter.cur_pos;
if (cur_pos >= no_db_nodes())
return 0;
Ndb_cluster_connection_impl::Node *nodes= m_all_nodes.getBase();
Ndb_cluster_connection_impl::Node &node= nodes[cur_pos];
if (iter.scan_state != (Uint8)~0)
{
assert(iter.scan_state < no_db_nodes());
if (nodes[iter.scan_state].group == node.group)
iter.scan_state= ~0;
else
return nodes[iter.scan_state++].id;
}
// fprintf(stderr,"[%d]",node.id);
cur_pos++;
Uint32 init_pos= iter.init_pos;
if (cur_pos == node.next_group)
{
cur_pos= nodes[init_pos].this_group;
}
// fprintf(stderr,"[cur_pos %d]",cur_pos);
if (cur_pos != init_pos)
iter.cur_pos= cur_pos;
else
{
iter.cur_pos= node.next_group;
iter.init_pos= node.next_group;
}
return node.id;
}
int
Ndb_cluster_connection::wait_until_ready(int timeout,
int timeout_after_first_alive)
{
DBUG_ENTER("Ndb_cluster_connection::wait_until_ready");
TransporterFacade *tp = m_impl.m_transporter_facade;
if (tp == 0)
{
DBUG_RETURN(-1);
}
if (tp->ownId() == 0)
{
DBUG_RETURN(-1);
}
int secondsCounter = 0;
int milliCounter = 0;
int noChecksSinceFirstAliveFound = 0;
do {
unsigned int foundAliveNode = get_no_ready();
if (foundAliveNode == no_db_nodes())
{
DBUG_RETURN(0);
}
else if (foundAliveNode > 0)
{
noChecksSinceFirstAliveFound++;
// 100 ms delay -> 10*
if (noChecksSinceFirstAliveFound > 10*timeout_after_first_alive)
DBUG_RETURN(1);
}
else if (secondsCounter >= timeout)
{ // no alive nodes and timed out
DBUG_RETURN(-1);
}
NdbSleep_MilliSleep(100);
milliCounter += 100;
if (milliCounter >= 1000) {
secondsCounter++;
milliCounter = 0;
}//if
} while (1);
}
int Ndb_cluster_connection::get_no_ready()
{
TransporterFacade *tp = m_impl.m_transporter_facade;
if (tp == 0 || tp->ownId() == 0)
return -1;
unsigned int foundAliveNode = 0;
tp->lock_mutex();
for(unsigned i= 0; i < no_db_nodes(); i++)
{
//************************************************
// If any node is answering, ndb is answering
//************************************************
if (tp->get_node_alive(m_impl.m_all_nodes[i].id) != 0) {
foundAliveNode++;
}
}
tp->unlock_mutex();
return foundAliveNode;
}
