int
NdbRestarter::connect(){
disconnect();
handle = ndb_mgm_create_handle();
if (handle == NULL){
g_err << "handle == NULL" << endl;
return -1;
}
g_info << "Connecting to mgmsrv at " << addr.c_str() << endl;
if (ndb_mgm_set_connectstring(handle,addr.c_str()))
{
MGMERR(handle);
g_err << "Connection to " << addr.c_str() << " failed" << endl;
return -1;
}
if (ndb_mgm_connect(handle, 0, 0, 0) == -1)
{
MGMERR(handle);
g_err << "Connection to " << addr.c_str() << " failed" << endl;
return -1;
}
connected = true;
return 0;
}
/**
* Given a SocketClient, creates a NdbMgmHandle, turns it into a transporter
* and returns the socket.
*/
NDB_SOCKET_TYPE TransporterRegistry::connect_ndb_mgmd(SocketClient *sc)
{
NdbMgmHandle h= ndb_mgm_create_handle();
if ( h == NULL )
{
return NDB_INVALID_SOCKET;
}
/**
* Set connectstring
*/
{
BaseString cs;
cs.assfmt("%s:%u",sc->get_server_name(),sc->get_port());
ndb_mgm_set_connectstring(h, cs.c_str());
}
if(ndb_mgm_connect(h, 0, 0, 0)<0)
{
ndb_mgm_destroy_handle(&h);
return NDB_INVALID_SOCKET;
}
return connect_ndb_mgmd(&h);
}
ndb_mgm_configuration*
fetch_configuration()
{
ndb_mgm_configuration* conf = 0;
NdbMgmHandle mgm = ndb_mgm_create_handle();
if(mgm == NULL) {
fprintf(stderr, "Cannot create handle to management server.\n");
return 0;
}
ndb_mgm_set_error_stream(mgm, stderr);
if (ndb_mgm_set_connectstring(mgm, opt_connect_str))
{
fprintf(stderr, "* %5d: %s\n",
ndb_mgm_get_latest_error(mgm),
ndb_mgm_get_latest_error_msg(mgm));
fprintf(stderr,
"* %s", ndb_mgm_get_latest_error_desc(mgm));
goto noconnect;
}
if(ndb_mgm_connect(mgm, try_reconnect-1, 5, 1))
{
fprintf(stderr, "Connect failed");
fprintf(stderr, " code: %d, msg: %s\n",
ndb_mgm_get_latest_error(mgm),
ndb_mgm_get_latest_error_msg(mgm));
goto noconnect;
}
else if(g_verbose)
{
fprintf(stderr, "Connected to %s:%d\n",
ndb_mgm_get_connected_host(mgm),
ndb_mgm_get_connected_port(mgm));
}
conf = ndb_mgm_get_configuration(mgm, 0);
if(conf == 0)
{
fprintf(stderr, "Could not get configuration");
fprintf(stderr, "code: %d, msg: %s\n",
ndb_mgm_get_latest_error(mgm),
ndb_mgm_get_latest_error_msg(mgm));
}
else if(g_verbose)
{
fprintf(stderr, "Fetched configuration\n");
}
ndb_mgm_disconnect(mgm);
noconnect:
ndb_mgm_destroy_handle(&mgm);
return conf;
}
int runTestApiSession(NDBT_Context* ctx, NDBT_Step* step)
{
char *mgm= ctx->getRemoteMgm();
Uint64 session_id= 0;
NdbMgmHandle h;
h= ndb_mgm_create_handle();
ndb_mgm_set_connectstring(h, mgm);
ndb_mgm_connect(h,0,0,0);
int s= ndb_mgm_get_fd(h);
session_id= ndb_mgm_get_session_id(h);
ndbout << "MGM Session id: " << session_id << endl;
write(s,"get",3);
ndb_mgm_disconnect(h);
ndb_mgm_destroy_handle(&h);
struct NdbMgmSession sess;
int slen= sizeof(struct NdbMgmSession);
h= ndb_mgm_create_handle();
ndb_mgm_set_connectstring(h, mgm);
ndb_mgm_connect(h,0,0,0);
NdbSleep_SecSleep(1);
if(ndb_mgm_get_session(h,session_id,&sess,&slen))
{
ndbout << "Failed, session still exists" << endl;
ndb_mgm_disconnect(h);
ndb_mgm_destroy_handle(&h);
return NDBT_FAILED;
}
else
{
ndbout << "SUCCESS: session is gone" << endl;
ndb_mgm_disconnect(h);
ndb_mgm_destroy_handle(&h);
return NDBT_OK;
}
}
ConfigRetriever::ConfigRetriever(const char * _connect_string,
int force_nodeid,
Uint32 version,
ndb_mgm_node_type node_type,
const char * _bindaddress,
int timeout_ms) :
m_end_session(true),
m_version(version),
m_node_type(node_type)
{
DBUG_ENTER("ConfigRetriever::ConfigRetriever");
DBUG_PRINT("enter", ("connect_string: '%s', force_nodeid: %d",
_connect_string, force_nodeid));
DBUG_PRINT("enter", ("version: %d, node_type: %d, bind: %s, timeout: %d",
version, node_type,_bindaddress, timeout_ms));
m_handle= ndb_mgm_create_handle();
if (m_handle == 0) {
setError(CR_ERROR, "Unable to allocate mgm handle");
DBUG_VOID_RETURN;
}
ndb_mgm_set_timeout(m_handle, timeout_ms);
if (ndb_mgm_set_connectstring(m_handle, _connect_string))
{
BaseString tmp(ndb_mgm_get_latest_error_msg(m_handle));
tmp.append(" : ");
tmp.append(ndb_mgm_get_latest_error_desc(m_handle));
setError(CR_ERROR, tmp.c_str());
DBUG_VOID_RETURN;
}
if (force_nodeid &&
ndb_mgm_set_configuration_nodeid(m_handle, force_nodeid))
{
setError(CR_ERROR, "Failed to set forced nodeid");
DBUG_VOID_RETURN;
}
if (_bindaddress)
{
if (ndb_mgm_set_bindaddress(m_handle, _bindaddress))
{
setError(CR_ERROR, ndb_mgm_get_latest_error_desc(m_handle));
DBUG_VOID_RETURN;
}
}
resetError();
DBUG_VOID_RETURN;
}
bool connect(const char* connect_string = NULL,
int num_retries = 0, int retry_delay_in_seconds = 0) {
assert(m_handle == NULL);
m_handle= ndb_mgm_create_handle();
if (!m_handle){
error("connect: ndb_mgm_create_handle failed");
return false;
}
if (ndb_mgm_set_connectstring(m_handle,
connect_string ?
connect_string : getConnectString()) != 0){
error("connect: ndb_mgm_set_connectstring failed");
return false;
}
if (m_timeout > 0 &&
ndb_mgm_set_timeout(m_handle, m_timeout) != 0){
error("connect: ndb_mgm_set_timeout failed");
return false;
}
if (ndb_mgm_connect(m_handle,num_retries,retry_delay_in_seconds,0) != 0){
error("connect: ndb_mgm_connect failed");
return false;
}
// Handshake with the server to make sure it's really there
int major, minor, build;
char buf[16];
if (ndb_mgm_get_version(m_handle, &major, &minor, &build,
sizeof(buf), buf) != 1)
{
error("connect: ndb_get_version failed");
return false;
}
//printf("connected to ndb_mgmd version %d.%d.%d\n",
// major, minor, build);
if ((m_nodeid = ndb_mgm_get_mgmd_nodeid(m_handle)) == 0){
error("connect: could not get nodeid of connected mgmd");
return false;
}
return true;
}
int main()
{
NdbMgmHandle handle= ndb_mgm_create_handle();
while(1==1){
if (ndb_mgm_connect(handle,0,0,0) == -1){
printf("connect failed, error: '%d: %s'\n",
ndb_mgm_get_latest_error(handle),
ndb_mgm_get_latest_error_desc(handle));
sleep(1);
continue;
}
while(ndb_mgm_is_connected(handle) != 0){
struct ndb_mgm_cluster_state *state= ndb_mgm_get_status(handle);
if(state==NULL){
printf("ndb_mgm_get_status failed, error: '%d: %s', line: %d\n",
ndb_mgm_get_latest_error(handle),
ndb_mgm_get_latest_error_desc(handle),
ndb_mgm_get_latest_error_line(handle));
continue;
}
int i= 0;
for(i=0; i < state->no_of_nodes; i++)
{
struct ndb_mgm_node_state *node_state= &state->node_states[i];
printf("node with ID=%d ", node_state->node_id);
if(node_state->version != 0)
printf("connected\n");
else
printf("not connected\n");
}
free((void*)state);
}
}
ndb_mgm_destroy_handle(&handle);
return 1;
}
ConfigRetriever::ConfigRetriever(const char * _connect_string,
Uint32 version, Uint32 node_type,
const char * _bindaddress,
int timeout_ms)
{
DBUG_ENTER("ConfigRetriever::ConfigRetriever");
m_version = version;
m_node_type = node_type;
_ownNodeId= 0;
m_end_session= true;
m_handle= ndb_mgm_create_handle();
if (m_handle == 0) {
setError(CR_ERROR, "Unable to allocate mgm handle");
DBUG_VOID_RETURN;
}
ndb_mgm_set_timeout(m_handle, timeout_ms);
if (ndb_mgm_set_connectstring(m_handle, _connect_string))
{
BaseString tmp(ndb_mgm_get_latest_error_msg(m_handle));
tmp.append(" : ");
tmp.append(ndb_mgm_get_latest_error_desc(m_handle));
setError(CR_ERROR, tmp.c_str());
DBUG_VOID_RETURN;
}
if (_bindaddress)
{
if (ndb_mgm_set_bindaddress(m_handle, _bindaddress))
{
setError(CR_ERROR, ndb_mgm_get_latest_error_desc(m_handle));
DBUG_VOID_RETURN;
}
}
resetError();
DBUG_VOID_RETURN;
}
int runTestApiTimeoutBasic(NDBT_Context* ctx, NDBT_Step* step)
{
char *mgm= ctx->getRemoteMgm();
int result= NDBT_FAILED;
int cc= 0;
int mgmd_nodeid= 0;
ndb_mgm_reply reply;
NdbMgmHandle h;
h= ndb_mgm_create_handle();
ndb_mgm_set_connectstring(h, mgm);
ndbout << "TEST timout check_connection" << endl;
int errs[] = { 1, 2, 3, -1};
for(int error_ins_no=0; errs[error_ins_no]!=-1; error_ins_no++)
{
int error_ins= errs[error_ins_no];
ndbout << "trying error " << error_ins << endl;
ndb_mgm_connect(h,0,0,0);
if(ndb_mgm_check_connection(h) < 0)
{
result= NDBT_FAILED;
goto done;
}
mgmd_nodeid= ndb_mgm_get_mgmd_nodeid(h);
if(mgmd_nodeid==0)
{
ndbout << "Failed to get mgmd node id to insert error" << endl;
result= NDBT_FAILED;
goto done;
}
reply.return_code= 0;
if(ndb_mgm_insert_error(h, mgmd_nodeid, error_ins, &reply)< 0)
{
ndbout << "failed to insert error " << endl;
result= NDBT_FAILED;
goto done;
}
ndb_mgm_set_timeout(h,2500);
cc= ndb_mgm_check_connection(h);
if(cc < 0)
result= NDBT_OK;
else
result= NDBT_FAILED;
if(ndb_mgm_is_connected(h))
{
ndbout << "FAILED: still connected" << endl;
result= NDBT_FAILED;
}
}
ndbout << "TEST get_mgmd_nodeid" << endl;
ndb_mgm_connect(h,0,0,0);
if(ndb_mgm_insert_error(h, mgmd_nodeid, 0, &reply)< 0)
{
ndbout << "failed to remove inserted error " << endl;
result= NDBT_FAILED;
goto done;
}
cc= ndb_mgm_get_mgmd_nodeid(h);
ndbout << "got node id: " << cc << endl;
if(cc==0)
{
ndbout << "FAILED: didn't get node id" << endl;
result= NDBT_FAILED;
}
else
result= NDBT_OK;
ndbout << "TEST end_session" << endl;
ndb_mgm_connect(h,0,0,0);
if(ndb_mgm_insert_error(h, mgmd_nodeid, 4, &reply)< 0)
{
ndbout << "FAILED: insert error 1" << endl;
result= NDBT_FAILED;
goto done;
}
cc= ndb_mgm_end_session(h);
if(cc==0)
{
ndbout << "FAILED: success in calling end_session" << endl;
result= NDBT_FAILED;
}
else if(ndb_mgm_get_latest_error(h)!=ETIMEDOUT)
{
ndbout << "FAILED: Incorrect error code (" << ndb_mgm_get_latest_error(h)
<< " != expected " << ETIMEDOUT << ") desc: "
<< ndb_mgm_get_latest_error_desc(h)
<< " line: " << ndb_mgm_get_latest_error_line(h)
<< " msg: " << ndb_mgm_get_latest_error_msg(h)
<< endl;
result= NDBT_FAILED;
}
else
result= NDBT_OK;
if(ndb_mgm_is_connected(h))
{
ndbout << "FAILED: is still connected after error" << endl;
result= NDBT_FAILED;
}
done:
ndb_mgm_disconnect(h);
ndb_mgm_destroy_handle(&h);
return result;
}
static int
waitClusterStatus(const char* _addr,
ndb_mgm_node_status _status)
{
int _startphase = -1;
/* Ignore SIGPIPE */
signal(SIGPIPE, SIG_IGN);
handle = ndb_mgm_create_handle();
if (handle == NULL){
g_err << "Could not create ndb_mgm handle" << endl;
return -1;
}
g_info << "Connecting to mgmsrv at " << _addr << endl;
if (ndb_mgm_set_connectstring(handle, _addr))
{
MGMERR(handle);
g_err << "Connectstring " << _addr << " invalid" << endl;
return -1;
}
if (ndb_mgm_connect(handle,0,0,1)) {
MGMERR(handle);
g_err << "Connection to " << _addr << " failed" << endl;
return -1;
}
int attempts = 0;
int resetAttempts = 0;
const int MAX_RESET_ATTEMPTS = 10;
bool allInState = false;
int timeout_ms= _timeout * 10; /* In number of 100 milliseconds */
while (allInState == false){
if (_timeout > 0 && attempts > _timeout){
/**
* Timeout has expired waiting for the nodes to enter
* the state we want
*/
bool waitMore = false;
/**
* Make special check if we are waiting for
* cluster to become started
*/
if(_status == NDB_MGM_NODE_STATUS_STARTED){
waitMore = true;
/**
* First check if any node is not starting
* then it's no idea to wait anymore
*/
for (size_t n = 0; n < ndbNodes.size(); n++){
if (ndbNodes[n].node_status != NDB_MGM_NODE_STATUS_STARTED &&
ndbNodes[n].node_status != NDB_MGM_NODE_STATUS_STARTING)
waitMore = false;
}
}
if (!waitMore || resetAttempts > MAX_RESET_ATTEMPTS){
g_err << "waitNodeState("
<< ndb_mgm_get_node_status_string(_status)
<<", "<<_startphase<<")"
<< " timeout after " << attempts <<" attemps" << endl;
return -1;
}
g_err << "waitNodeState("
<< ndb_mgm_get_node_status_string(_status)
<<", "<<_startphase<<")"
<< " resetting number of attempts "
<< resetAttempts << endl;
attempts = 0;
resetAttempts++;
}
if (getStatus() != 0){
return -1;
}
/* Assume all nodes are in state(if there is any) */
allInState = (ndbNodes.size() > 0);
/* Loop through all nodes and check their state */
for (size_t n = 0; n < ndbNodes.size(); n++) {
ndb_mgm_node_state* ndbNode = &ndbNodes[n];
assert(ndbNode != NULL);
g_info << "Node " << ndbNode->node_id << ": "
<< ndb_mgm_get_node_status_string(ndbNode->node_status)<< endl;
if (ndbNode->node_status != _status)
allInState = false;
}
if (!allInState) {
g_info << "Waiting for cluster enter state "
<< ndb_mgm_get_node_status_string(_status)<< endl;
NdbSleep_MilliSleep(100);
}
attempts++;
}
return 0;
}
int runTestMgmApiStructEventTimeout(NDBT_Context* ctx, NDBT_Step* step)
{
char *mgm= ctx->getRemoteMgm();
int result= NDBT_OK;
int mgmd_nodeid= 0;
NdbMgmHandle h;
h= ndb_mgm_create_handle();
ndb_mgm_set_connectstring(h, mgm);
int errs[] = { 10000, 0, -1 };
for(int error_ins_no=0; errs[error_ins_no]!=-1; error_ins_no++)
{
int error_ins= errs[error_ins_no];
ndb_mgm_connect(h,0,0,0);
if(ndb_mgm_check_connection(h) < 0)
{
result= NDBT_FAILED;
goto done;
}
mgmd_nodeid= ndb_mgm_get_mgmd_nodeid(h);
if(mgmd_nodeid==0)
{
ndbout << "Failed to get mgmd node id to insert error" << endl;
result= NDBT_FAILED;
goto done;
}
ndb_mgm_reply reply;
reply.return_code= 0;
if(ndb_mgm_insert_error(h, mgmd_nodeid, error_ins, &reply)< 0)
{
ndbout << "failed to insert error " << error_ins << endl;
result= NDBT_FAILED;
}
ndbout << "trying error: " << error_ins << endl;
ndb_mgm_set_timeout(h,2500);
int filter[] = { 15, NDB_MGM_EVENT_CATEGORY_BACKUP,
1, NDB_MGM_EVENT_CATEGORY_STARTUP,
0 };
NdbLogEventHandle le_handle= ndb_mgm_create_logevent_handle(h, filter);
struct ndb_logevent le;
for(int i=0; i<20; i++)
{
if(error_ins==0 || (error_ins!=0 && i<5))
{
Uint32 theData[25];
EventReport *fake_event = (EventReport*)theData;
fake_event->setEventType(NDB_LE_NDBStopForced);
fake_event->setNodeId(42);
theData[2]= 0;
theData[3]= 0;
theData[4]= 0;
theData[5]= 0;
ndb_mgm_report_event(h, theData, 6);
}
int r= ndb_logevent_get_next(le_handle, &le, 2500);
if(r>0)
{
ndbout << "Receieved event" << endl;
}
else if(r<0)
{
ndbout << "ERROR" << endl;
}
else // no event
{
ndbout << "TIMED OUT READING EVENT at iteration " << i << endl;
if(error_ins==0)
result= NDBT_FAILED;
else
result= NDBT_OK;
break;
}
}
/*
* events go through a *DIFFERENT* socket than the NdbMgmHandle
* so we should still be connected (and be able to check_connection)
*
*/
if(ndb_mgm_check_connection(h) && !ndb_mgm_is_connected(h))
{
ndbout << "FAILED: is still connected after error" << endl;
result= NDBT_FAILED;
}
ndb_mgm_disconnect(h);
}
done:
ndb_mgm_disconnect(h);
ndb_mgm_destroy_handle(&h);
return result;
}
int runTestMgmApiEventTimeout(NDBT_Context* ctx, NDBT_Step* step)
{
char *mgm= ctx->getRemoteMgm();
int result= NDBT_OK;
int mgmd_nodeid= 0;
NdbMgmHandle h;
h= ndb_mgm_create_handle();
ndb_mgm_set_connectstring(h, mgm);
int errs[] = { 10000, 0, -1 };
for(int error_ins_no=0; errs[error_ins_no]!=-1; error_ins_no++)
{
int error_ins= errs[error_ins_no];
ndb_mgm_connect(h,0,0,0);
if(ndb_mgm_check_connection(h) < 0)
{
result= NDBT_FAILED;
goto done;
}
mgmd_nodeid= ndb_mgm_get_mgmd_nodeid(h);
if(mgmd_nodeid==0)
{
ndbout << "Failed to get mgmd node id to insert error" << endl;
result= NDBT_FAILED;
goto done;
}
ndb_mgm_reply reply;
reply.return_code= 0;
if(ndb_mgm_insert_error(h, mgmd_nodeid, error_ins, &reply)< 0)
{
ndbout << "failed to insert error " << error_ins << endl;
result= NDBT_FAILED;
}
ndbout << "trying error: " << error_ins << endl;
ndb_mgm_set_timeout(h,2500);
int filter[] = { 15, NDB_MGM_EVENT_CATEGORY_BACKUP,
1, NDB_MGM_EVENT_CATEGORY_STARTUP,
0 };
int fd= ndb_mgm_listen_event(h, filter);
if(fd==NDB_INVALID_SOCKET)
{
ndbout << "FAILED: could not listen to event" << endl;
result= NDBT_FAILED;
}
Uint32 theData[25];
EventReport *fake_event = (EventReport*)theData;
fake_event->setEventType(NDB_LE_NDBStopForced);
fake_event->setNodeId(42);
theData[2]= 0;
theData[3]= 0;
theData[4]= 0;
theData[5]= 0;
ndb_mgm_report_event(h, theData, 6);
char *tmp= 0;
char buf[512];
SocketInputStream in(fd,2000);
for(int i=0; i<20; i++)
{
if((tmp = in.gets(buf, sizeof(buf))))
{
// const char ping_token[]="<PING>";
// if(memcmp(ping_token,tmp,sizeof(ping_token)-1))
if(tmp && strlen(tmp))
ndbout << tmp;
}
else
{
if(in.timedout())
{
ndbout << "TIMED OUT READING EVENT at iteration " << i << endl;
break;
}
}
}
/*
* events go through a *DIFFERENT* socket than the NdbMgmHandle
* so we should still be connected (and be able to check_connection)
*
*/
if(ndb_mgm_check_connection(h) && !ndb_mgm_is_connected(h))
{
ndbout << "FAILED: is still connected after error" << endl;
result= NDBT_FAILED;
}
ndb_mgm_disconnect(h);
}
done:
ndb_mgm_disconnect(h);
ndb_mgm_destroy_handle(&h);
return result;
}
int runTestMgmApiGetConfigTimeout(NDBT_Context* ctx, NDBT_Step* step)
{
char *mgm= ctx->getRemoteMgm();
int result= NDBT_OK;
int mgmd_nodeid= 0;
NdbMgmHandle h;
h= ndb_mgm_create_handle();
ndb_mgm_set_connectstring(h, mgm);
int errs[] = { 0, 1, 2, 3, -1 };
for(int error_ins_no=0; errs[error_ins_no]!=-1; error_ins_no++)
{
int error_ins= errs[error_ins_no];
ndb_mgm_connect(h,0,0,0);
if(ndb_mgm_check_connection(h) < 0)
{
result= NDBT_FAILED;
goto done;
}
mgmd_nodeid= ndb_mgm_get_mgmd_nodeid(h);
if(mgmd_nodeid==0)
{
ndbout << "Failed to get mgmd node id to insert error" << endl;
result= NDBT_FAILED;
goto done;
}
ndb_mgm_reply reply;
reply.return_code= 0;
if(ndb_mgm_insert_error(h, mgmd_nodeid, error_ins, &reply)< 0)
{
ndbout << "failed to insert error " << error_ins << endl;
result= NDBT_FAILED;
}
ndbout << "trying error: " << error_ins << endl;
ndb_mgm_set_timeout(h,2500);
struct ndb_mgm_configuration *c= ndb_mgm_get_configuration(h,0);
if(c!=NULL)
free(c);
if(error_ins!=0 && c!=NULL)
{
ndbout << "FAILED: got a ndb_mgm_configuration back" << endl;
result= NDBT_FAILED;
}
if(error_ins!=0 && ndb_mgm_is_connected(h))
{
ndbout << "FAILED: is still connected after error" << endl;
result= NDBT_FAILED;
}
if(error_ins!=0 && ndb_mgm_get_latest_error(h)!=ETIMEDOUT)
{
ndbout << "FAILED: Incorrect error code (" << ndb_mgm_get_latest_error(h)
<< " != expected " << ETIMEDOUT << ") desc: "
<< ndb_mgm_get_latest_error_desc(h)
<< " line: " << ndb_mgm_get_latest_error_line(h)
<< " msg: " << ndb_mgm_get_latest_error_msg(h)
<< endl;
result= NDBT_FAILED;
}
}
done:
ndb_mgm_disconnect(h);
ndb_mgm_destroy_handle(&h);
return result;
}
int runTestApiGetStatusTimeout(NDBT_Context* ctx, NDBT_Step* step)
{
char *mgm= ctx->getRemoteMgm();
int result= NDBT_OK;
int cc= 0;
int mgmd_nodeid= 0;
NdbMgmHandle h;
h= ndb_mgm_create_handle();
ndb_mgm_set_connectstring(h, mgm);
int errs[] = { 0, 5, 6, 7, 8, 9, -1 };
for(int error_ins_no=0; errs[error_ins_no]!=-1; error_ins_no++)
{
int error_ins= errs[error_ins_no];
ndb_mgm_connect(h,0,0,0);
if(ndb_mgm_check_connection(h) < 0)
{
result= NDBT_FAILED;
goto done;
}
mgmd_nodeid= ndb_mgm_get_mgmd_nodeid(h);
if(mgmd_nodeid==0)
{
ndbout << "Failed to get mgmd node id to insert error" << endl;
result= NDBT_FAILED;
goto done;
}
ndb_mgm_reply reply;
reply.return_code= 0;
if(ndb_mgm_insert_error(h, mgmd_nodeid, error_ins, &reply)< 0)
{
ndbout << "failed to insert error " << error_ins << endl;
result= NDBT_FAILED;
}
ndbout << "trying error: " << error_ins << endl;
ndb_mgm_set_timeout(h,2500);
struct ndb_mgm_cluster_state *cl= ndb_mgm_get_status(h);
if(cl!=NULL)
free(cl);
/*
* For whatever strange reason,
* get_status is okay with not having the last enter there.
* instead of "fixing" the api, let's have a special case
* so we don't break any behaviour
*/
if(error_ins!=0 && error_ins!=9 && cl!=NULL)
{
ndbout << "FAILED: got a ndb_mgm_cluster_state back" << endl;
result= NDBT_FAILED;
}
if(error_ins!=0 && error_ins!=9 && ndb_mgm_is_connected(h))
{
ndbout << "FAILED: is still connected after error" << endl;
result= NDBT_FAILED;
}
if(error_ins!=0 && error_ins!=9 && ndb_mgm_get_latest_error(h)!=ETIMEDOUT)
{
ndbout << "FAILED: Incorrect error code (" << ndb_mgm_get_latest_error(h)
<< " != expected " << ETIMEDOUT << ") desc: "
<< ndb_mgm_get_latest_error_desc(h)
<< " line: " << ndb_mgm_get_latest_error_line(h)
<< " msg: " << ndb_mgm_get_latest_error_msg(h)
<< endl;
result= NDBT_FAILED;
}
}
done:
ndb_mgm_disconnect(h);
ndb_mgm_destroy_handle(&h);
return result;
}
Uint32
IPCConfig::configureTransporters(Uint32 nodeId,
const class ndb_mgm_configuration & config,
class TransporterRegistry & tr){
TransporterConfiguration conf;
DBUG_ENTER("IPCConfig::configureTransporters");
/**
* Iterate over all MGM's an construct a connectstring
* create mgm_handle and give it to the Transporter Registry
*/
{
const char *separator= "";
BaseString connect_string;
ndb_mgm_configuration_iterator iter(config, CFG_SECTION_NODE);
for(iter.first(); iter.valid(); iter.next())
{
Uint32 type;
if(iter.get(CFG_TYPE_OF_SECTION, &type)) continue;
if(type != NODE_TYPE_MGM) continue;
const char* hostname;
Uint32 port;
if(iter.get(CFG_NODE_HOST, &hostname)) continue;
if( strlen(hostname) == 0 ) continue;
if(iter.get(CFG_MGM_PORT, &port)) continue;
connect_string.appfmt("%s%s:%u",separator,hostname,port);
separator= ",";
}
NdbMgmHandle h= ndb_mgm_create_handle();
if ( h && connect_string.length() > 0 )
{
ndb_mgm_set_connectstring(h,connect_string.c_str());
tr.set_mgm_handle(h);
}
}
Uint32 noOfTransportersCreated= 0;
ndb_mgm_configuration_iterator iter(config, CFG_SECTION_CONNECTION);
for(iter.first(); iter.valid(); iter.next()){
Uint32 nodeId1, nodeId2, remoteNodeId;
const char * remoteHostName= 0, * localHostName= 0;
if(iter.get(CFG_CONNECTION_NODE_1, &nodeId1)) continue;
if(iter.get(CFG_CONNECTION_NODE_2, &nodeId2)) continue;
if(nodeId1 != nodeId && nodeId2 != nodeId) continue;
remoteNodeId = (nodeId == nodeId1 ? nodeId2 : nodeId1);
{
const char * host1= 0, * host2= 0;
iter.get(CFG_CONNECTION_HOSTNAME_1, &host1);
iter.get(CFG_CONNECTION_HOSTNAME_2, &host2);
localHostName = (nodeId == nodeId1 ? host1 : host2);
remoteHostName = (nodeId == nodeId1 ? host2 : host1);
}
Uint32 sendSignalId = 1;
Uint32 checksum = 1;
if(iter.get(CFG_CONNECTION_SEND_SIGNAL_ID, &sendSignalId)) continue;
if(iter.get(CFG_CONNECTION_CHECKSUM, &checksum)) continue;
Uint32 type = ~0;
if(iter.get(CFG_TYPE_OF_SECTION, &type)) continue;
Uint32 server_port= 0;
if(iter.get(CFG_CONNECTION_SERVER_PORT, &server_port)) break;
Uint32 nodeIdServer= 0;
if(iter.get(CFG_CONNECTION_NODE_ID_SERVER, &nodeIdServer)) break;
/*
We check the node type.
*/
Uint32 node1type, node2type;
ndb_mgm_configuration_iterator node1iter(config, CFG_SECTION_NODE);
ndb_mgm_configuration_iterator node2iter(config, CFG_SECTION_NODE);
node1iter.find(CFG_NODE_ID,nodeId1);
node2iter.find(CFG_NODE_ID,nodeId2);
node1iter.get(CFG_TYPE_OF_SECTION,&node1type);
node2iter.get(CFG_TYPE_OF_SECTION,&node2type);
if(node1type==NODE_TYPE_MGM || node2type==NODE_TYPE_MGM)
conf.isMgmConnection= true;
else
conf.isMgmConnection= false;
if (nodeId == nodeIdServer && !conf.isMgmConnection) {
tr.add_transporter_interface(remoteNodeId, localHostName, server_port);
}
DBUG_PRINT("info", ("Transporter between this node %d and node %d using port %d, signalId %d, checksum %d",
nodeId, remoteNodeId, server_port, sendSignalId, checksum));
/*
This may be a dynamic port. It depends on when we're getting
our configuration. If we've been restarted, we'll be getting
a configuration with our old dynamic port in it, hence the number
here is negative (and we try the old port number first).
On a first-run, server_port will be zero (with dynamic ports)
If we're not using dynamic ports, we don't do anything.
*/
conf.localNodeId = nodeId;
conf.remoteNodeId = remoteNodeId;
conf.checksum = checksum;
conf.signalId = sendSignalId;
conf.s_port = server_port;
conf.localHostName = localHostName;
conf.remoteHostName = remoteHostName;
conf.serverNodeId = nodeIdServer;
switch(type){
case CONNECTION_TYPE_SHM:
if(iter.get(CFG_SHM_KEY, &conf.shm.shmKey)) break;
if(iter.get(CFG_SHM_BUFFER_MEM, &conf.shm.shmSize)) break;
Uint32 tmp;
if(iter.get(CFG_SHM_SIGNUM, &tmp)) break;
conf.shm.signum= tmp;
if(!tr.createSHMTransporter(&conf)){
DBUG_PRINT("error", ("Failed to create SHM Transporter from %d to %d",
conf.localNodeId, conf.remoteNodeId));
ndbout << "Failed to create SHM Transporter from: "
<< conf.localNodeId << " to: " << conf.remoteNodeId << endl;
} else {
noOfTransportersCreated++;
}
DBUG_PRINT("info", ("Created SHM Transporter using shmkey %d, "
"buf size = %d", conf.shm.shmKey, conf.shm.shmSize));
break;
case CONNECTION_TYPE_SCI:
if(iter.get(CFG_SCI_SEND_LIMIT, &conf.sci.sendLimit)) break;
if(iter.get(CFG_SCI_BUFFER_MEM, &conf.sci.bufferSize)) break;
if (nodeId == nodeId1) {
if(iter.get(CFG_SCI_HOST2_ID_0, &conf.sci.remoteSciNodeId0)) break;
if(iter.get(CFG_SCI_HOST2_ID_1, &conf.sci.remoteSciNodeId1)) break;
} else {
if(iter.get(CFG_SCI_HOST1_ID_0, &conf.sci.remoteSciNodeId0)) break;
if(iter.get(CFG_SCI_HOST1_ID_1, &conf.sci.remoteSciNodeId1)) break;
}
if (conf.sci.remoteSciNodeId1 == 0) {
conf.sci.nLocalAdapters = 1;
} else {
conf.sci.nLocalAdapters = 2;
}
if(!tr.createSCITransporter(&conf)){
DBUG_PRINT("error", ("Failed to create SCI Transporter from %d to %d",
conf.localNodeId, conf.remoteNodeId));
ndbout << "Failed to create SCI Transporter from: "
<< conf.localNodeId << " to: " << conf.remoteNodeId << endl;
} else {
DBUG_PRINT("info", ("Created SCI Transporter: Adapters = %d, "
"remote SCI node id %d",
conf.sci.nLocalAdapters, conf.sci.remoteSciNodeId0));
DBUG_PRINT("info", ("Host 1 = %s, Host 2 = %s, sendLimit = %d, "
"buf size = %d", conf.localHostName,
conf.remoteHostName, conf.sci.sendLimit,
conf.sci.bufferSize));
if (conf.sci.nLocalAdapters > 1) {
DBUG_PRINT("info", ("Fault-tolerant with 2 Remote Adapters, "
"second remote SCI node id = %d",
conf.sci.remoteSciNodeId1));
}
noOfTransportersCreated++;
continue;
}
break;
case CONNECTION_TYPE_TCP:
if(iter.get(CFG_TCP_SEND_BUFFER_SIZE, &conf.tcp.sendBufferSize)) break;
if(iter.get(CFG_TCP_RECEIVE_BUFFER_SIZE, &conf.tcp.maxReceiveSize)) break;
const char * proxy;
if (!iter.get(CFG_TCP_PROXY, &proxy)) {
if (strlen(proxy) > 0 && nodeId2 == nodeId) {
// TODO handle host:port
conf.s_port = atoi(proxy);
}
}
if(!tr.createTCPTransporter(&conf)){
ndbout << "Failed to create TCP Transporter from: "
<< nodeId << " to: " << remoteNodeId << endl;
} else {
noOfTransportersCreated++;
}
DBUG_PRINT("info", ("Created TCP Transporter: sendBufferSize = %d, "
"maxReceiveSize = %d", conf.tcp.sendBufferSize,
conf.tcp.maxReceiveSize));
break;
case CONNECTION_TYPE_OSE:
if(iter.get(CFG_OSE_PRIO_A_SIZE, &conf.ose.prioASignalSize)) break;
if(iter.get(CFG_OSE_PRIO_B_SIZE, &conf.ose.prioBSignalSize)) break;
if(!tr.createOSETransporter(&conf)){
ndbout << "Failed to create OSE Transporter from: "
<< nodeId << " to: " << remoteNodeId << endl;
} else {
noOfTransportersCreated++;
}
break;
default:
ndbout << "Unknown transporter type from: " << nodeId <<
" to: " << remoteNodeId << endl;
break;
} // switch
} // for
DBUG_RETURN(noOfTransportersCreated);
}
int runTestApiConnectTimeout(NDBT_Context* ctx, NDBT_Step* step)
{
char *mgm= ctx->getRemoteMgm();
int result= NDBT_FAILED;
int cc= 0;
int mgmd_nodeid= 0;
ndb_mgm_reply reply;
NdbMgmHandle h;
h= ndb_mgm_create_handle();
ndb_mgm_set_connectstring(h, mgm);
ndbout << "TEST connect timeout" << endl;
ndb_mgm_set_timeout(h, 3000);
struct timeval tstart, tend;
int secs;
timerclear(&tstart);
timerclear(&tend);
gettimeofday(&tstart,NULL);
ndb_mgm_connect(h,0,0,0);
gettimeofday(&tend,NULL);
secs= tend.tv_sec - tstart.tv_sec;
ndbout << "Took about: " << secs <<" seconds"<<endl;
if(secs < 4)
result= NDBT_OK;
else
goto done;
ndb_mgm_set_connectstring(h, mgm);
ndbout << "TEST connect timeout" << endl;
ndb_mgm_destroy_handle(&h);
h= ndb_mgm_create_handle();
ndb_mgm_set_connectstring(h, "1.1.1.1");
ndbout << "TEST connect timeout (invalid host)" << endl;
ndb_mgm_set_timeout(h, 3000);
timerclear(&tstart);
timerclear(&tend);
gettimeofday(&tstart,NULL);
ndb_mgm_connect(h,0,0,0);
gettimeofday(&tend,NULL);
secs= tend.tv_sec - tstart.tv_sec;
ndbout << "Took about: " << secs <<" seconds"<<endl;
if(secs < 4)
result= NDBT_OK;
else
result= NDBT_FAILED;
done:
ndb_mgm_disconnect(h);
ndb_mgm_destroy_handle(&h);
return result;
}
int
main(int argc, char** argv)
{
NDB_INIT(argv[0]);
const char *load_default_groups[]= { "mysql_cluster",0 };
ndb_load_defaults(NULL,load_default_groups,&argc,&argv);
int ho_error;
#ifndef DBUG_OFF
opt_debug= "d:t:O,/tmp/eventlog.trace";
#endif
#ifndef _WIN32
// Catching signal to allow testing of EINTR safeness
// with "while killall -USR1 eventlog; do true; done"
signal(SIGUSR1, catch_signal);
#endif
if ((ho_error=handle_options(&argc, &argv, my_long_options,
ndb_std_get_one_option)))
return NDBT_ProgramExit(NDBT_WRONGARGS);
NdbMgmHandle handle= ndb_mgm_create_handle();
ndb_mgm_set_connectstring(handle, opt_ndb_connectstring);
while (true)
{
if (ndb_mgm_connect(handle,0,0,0) == -1)
{
ndbout_c("Failed to connect");
exit(0);
}
NdbLogEventHandle le = ndb_mgm_create_logevent_handle(handle, filter);
if (le == 0)
{
ndbout_c("Failed to create logevent handle");
exit(0);
}
struct ndb_logevent event;
while (true)
{
int r= ndb_logevent_get_next(le, &event,5000);
if (r < 0)
{
ndbout_c("Error while getting next event");
break;
}
if (r == 0)
{
continue;
}
ndbout_c("Got event: %d", event.type);
}
ndb_mgm_destroy_logevent_handle(&le);
ndb_mgm_disconnect(handle);
}
return 0;
}
