int main(int argc, char** argv){
NDB_INIT(argv[0]);
const char* _tabname;
load_defaults("my",load_default_groups,&argc,&argv);
int ho_error;
#ifndef DBUG_OFF
opt_debug= "d:t:O,/tmp/ndb_show_tables.trace";
#endif
if ((ho_error=handle_options(&argc, &argv, my_long_options,
ndb_std_get_one_option)))
return NDBT_ProgramExit(NDBT_WRONGARGS);
_tabname = argv[0];
ndb_cluster_connection = new Ndb_cluster_connection(opt_connect_str);
ndb_cluster_connection->set_name("ndb_show_tables");
if (ndb_cluster_connection->connect(12,5,1))
fatal("Unable to connect to management server.");
if (ndb_cluster_connection->wait_until_ready(30,0) < 0)
fatal("Cluster nodes not ready in 30 seconds.");
ndb = new Ndb(ndb_cluster_connection, _dbname);
if (ndb->init() != 0)
fatal("init");
dic = ndb->getDictionary();
for (int i = 0; _loops == 0 || i < _loops; i++) {
list(_tabname, (NdbDictionary::Object::Type)_type);
}
delete ndb;
delete ndb_cluster_connection;
return NDBT_ProgramExit(NDBT_OK);
}
int main(int argc, char** argv){
NDB_INIT(argv[0]);
ndb_opt_set_usage_funcs(short_usage_sub, usage);
ndb_load_defaults(NULL,load_default_groups,&argc,&argv);
int ho_error;
#ifndef DBUG_OFF
opt_debug= "d:t:O,/tmp/ndb_desc.trace";
#endif
if ((ho_error=handle_options(&argc, &argv, my_long_options,
ndb_std_get_one_option)))
return NDBT_ProgramExit(NDBT_WRONGARGS);
Ndb_cluster_connection con(opt_ndb_connectstring, opt_ndb_nodeid);
con.set_name("ndb_desc");
if(con.connect(12, 5, 1) != 0)
{
ndbout << "Unable to connect to management server." << endl;
return NDBT_ProgramExit(NDBT_FAILED);
}
if (con.wait_until_ready(30,0) < 0)
{
ndbout << "Cluster nodes not ready in 30 seconds." << endl;
return NDBT_ProgramExit(NDBT_FAILED);
}
Ndb MyNdb(&con, _dbname);
if(MyNdb.init() != 0){
ERR(MyNdb.getNdbError());
return NDBT_ProgramExit(NDBT_FAILED);
}
for(int i= 0; i<argc;i++)
{
if (desc_index(&MyNdb, argv[i]))
;
else if(desc_table(&MyNdb, argv[i]))
;
else if(desc_tablespace(&MyNdb,argv[i]))
;
else if(desc_logfilegroup(&MyNdb,argv[i]))
;
else if(desc_datafile(con, &MyNdb, argv[i]))
;
else if(desc_undofile(con, &MyNdb, argv[i]))
;
else if (desc_hashmap(con, &MyNdb, argv[i]))
;
else
ndbout << "No such object: " << argv[i] << endl << endl;
}
return NDBT_ProgramExit(NDBT_OK);
}
int main(int argc, char** argv) {
NDB_INIT(argv[0]);
ndb_opt_set_usage_funcs(short_usage_sub, usage);
ndb_load_defaults(NULL,load_default_groups,&argc,&argv);
int ho_error;
#ifndef DBUG_OFF
opt_debug= "d:t:O,/tmp/ndb_select_count.trace";
#endif
if ((ho_error=handle_options(&argc, &argv, my_long_options,
ndb_std_get_one_option)))
return NDBT_ProgramExit(NDBT_WRONGARGS);
if (argc < 1) {
usage();
return NDBT_ProgramExit(NDBT_WRONGARGS);
}
Ndb_cluster_connection con(opt_ndb_connectstring, opt_ndb_nodeid);
con.set_name("ndb_select_count");
if(con.connect(12, 5, 1) != 0)
{
ndbout << "Unable to connect to management server." << endl;
return NDBT_ProgramExit(NDBT_FAILED);
}
if (con.wait_until_ready(30,0) < 0)
{
ndbout << "Cluster nodes not ready in 30 seconds." << endl;
return NDBT_ProgramExit(NDBT_FAILED);
}
Ndb MyNdb(&con, _dbname );
if(MyNdb.init() != 0) {
ERR(MyNdb.getNdbError());
return NDBT_ProgramExit(NDBT_FAILED);
}
for(int i = 0; i<argc; i++) {
// Check if table exists in db
const NdbDictionary::Table * pTab = NDBT_Table::discoverTableFromDb(&MyNdb, argv[i]);
if(pTab == NULL) {
ndbout << " Table " << argv[i] << " does not exist!" << endl;
continue;
}
Uint64 rows = 0;
if (select_count(&MyNdb, pTab, _parallelism, &rows,
(NdbOperation::LockMode)_lock) != 0) {
return NDBT_ProgramExit(NDBT_FAILED);
}
ndbout << rows << " records in table " << argv[i] << endl;
}
return NDBT_ProgramExit(NDBT_OK);
}
int main(int argc, char** argv){
NDB_INIT(argv[0]);
load_defaults("my",load_default_groups,&argc,&argv);
int ho_error;
if ((ho_error=handle_options(&argc, &argv, my_long_options,
ndb_std_get_one_option)))
return NDBT_ProgramExit(NDBT_WRONGARGS);
if (argc < 1) {
usage();
return NDBT_ProgramExit(NDBT_WRONGARGS);
}
Ndb_cluster_connection con(opt_connect_str);
con.set_name("ndb_drop_table");
if(con.connect(12, 5, 1) != 0)
{
ndbout << "Unable to connect to management server." << endl;
return NDBT_ProgramExit(NDBT_FAILED);
}
if (con.wait_until_ready(30,3) < 0)
{
ndbout << "Cluster nodes not ready in 30 seconds." << endl;
return NDBT_ProgramExit(NDBT_FAILED);
}
Ndb MyNdb(&con, _dbname );
if(MyNdb.init() != 0){
ERR(MyNdb.getNdbError());
return NDBT_ProgramExit(NDBT_FAILED);
}
int res = 0;
for(int i = 0; i<argc; i++){
ndbout << "Dropping table " << argv[i] << "...";
int tmp;
if((tmp = MyNdb.getDictionary()->dropTable(argv[i])) != 0){
ndbout << endl << MyNdb.getDictionary()->getNdbError() << endl;
res = tmp;
} else {
ndbout << "OK" << endl;
}
}
if(res != 0){
return NDBT_ProgramExit(NDBT_FAILED);
}
return NDBT_ProgramExit(NDBT_OK);
}
int main(int argc, char** argv){
NDB_INIT(argv[0]);
load_defaults("my",load_default_groups,&argc,&argv);
int ho_error;
#ifndef DBUG_OFF
opt_debug= "d:t:O,/tmp/ndb_delete_all.trace";
#endif
if ((ho_error=handle_options(&argc, &argv, my_long_options,
ndb_std_get_one_option)))
return NDBT_ProgramExit(NDBT_WRONGARGS);
Ndb_cluster_connection con(opt_connect_str);
con.set_name("ndb_delete_all");
if(con.connect(12, 5, 1) != 0)
{
ndbout << "Unable to connect to management server." << endl;
return NDBT_ProgramExit(NDBT_FAILED);
}
if (con.wait_until_ready(30,0) < 0)
{
ndbout << "Cluster nodes not ready in 30 seconds." << endl;
return NDBT_ProgramExit(NDBT_FAILED);
}
Ndb MyNdb(&con, _dbname );
if(MyNdb.init() != 0){
ERR(MyNdb.getNdbError());
return NDBT_ProgramExit(NDBT_FAILED);
}
// Check if table exists in db
int res = NDBT_OK;
for(int i = 0; i<argc; i++){
const NdbDictionary::Table * pTab = NDBT_Table::discoverTableFromDb(&MyNdb, argv[i]);
if(pTab == NULL){
ndbout << " Table " << argv[i] << " does not exist!" << endl;
return NDBT_ProgramExit(NDBT_WRONGARGS);
}
ndbout << "Deleting all from " << argv[i];
if (! _transactional)
ndbout << " (non-transactional)";
ndbout << " ...";
if(clear_table(&MyNdb, pTab, ! _transactional) == NDBT_FAILED){
res = NDBT_FAILED;
ndbout << "FAILED" << endl;
}
}
return NDBT_ProgramExit(res);
}
int
main(int argc, char** argv)
{
NDB_INIT("ndb_blob_tool");
int ret;
ndb_opt_set_usage_funcs(short_usage_sub, usage);
ret = handle_options(&argc, &argv, my_long_options, ndb_std_get_one_option);
if (ret != 0 || checkopts(argc, argv) != 0)
return NDBT_ProgramExit(NDBT_WRONGARGS);
setOutputLevel(opt_verbose ? 2 : 0);
ret = doall();
freeall();
if (ret == -1)
return NDBT_ProgramExit(NDBT_FAILED);
return NDBT_ProgramExit(NDBT_OK);
}
int main(int argc, char** argv){
NDB_INIT(argv[0]);
load_defaults("my",load_default_groups,&argc,&argv);
const char* _hostName = NULL;
#ifndef DBUG_OFF
opt_debug= "d:t:O,/tmp/ndb_waiter.trace";
#endif
if (handle_options(&argc, &argv, my_long_options,
ndb_std_get_one_option))
return NDBT_ProgramExit(NDBT_WRONGARGS);
_hostName = argv[0];
if (_hostName == 0)
_hostName= opt_connect_str;
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 (waitClusterStatus(_hostName, wait_status) != 0)
return NDBT_ProgramExit(NDBT_FAILED);
return NDBT_ProgramExit(NDBT_OK);
}
/*
* MAIN
*/
int main(int argc, char** argv)
{
NDB_INIT(argv[0]);
load_defaults("my",load_default_groups,&argc,&argv);
int ho_error;
#ifndef DBUG_OFF
opt_debug= "d:t:O,/tmp/ndb_mgmd.trace";
#endif
if ((ho_error=handle_options(&argc, &argv, my_long_options,
ndb_std_get_one_option)))
exit(ho_error);
start:
glob= new MgmGlobals;
/**
* OSE specific. Enable shared ownership of file system resources.
* This is needed in order to use the cluster log since the events
* from the cluster is written from the 'ndb_receive'(NDBAPI) thread/process.
*/
#if defined NDB_OSE || defined NDB_SOFTOSE
efs_segment_share();
#endif
global_mgmt_server_check = 1;
if (opt_interactive ||
opt_non_interactive ||
g_print_full_config) {
opt_daemon= 0;
}
if (opt_mycnf && opt_config_filename)
{
ndbout_c("Both --mycnf and -f is not supported");
return 0;
}
if (opt_mycnf == 0 && opt_config_filename == 0)
{
struct stat buf;
if (stat("config.ini", &buf) != -1)
opt_config_filename = "config.ini";
}
glob->socketServer = new SocketServer();
MgmApiService * mapi = new MgmApiService();
glob->mgmObject = new MgmtSrvr(glob->socketServer,
opt_config_filename,
opt_connect_str);
if (g_print_full_config)
goto the_end;
if (glob->mgmObject->init())
goto error_end;
my_setwd(NdbConfig_get_path(0), MYF(0));
glob->localNodeId= glob->mgmObject->getOwnNodeId();
if (glob->localNodeId == 0) {
goto error_end;
}
glob->port= glob->mgmObject->getPort();
if (glob->port == 0)
goto error_end;
glob->interface_name = 0;
glob->use_specific_ip = false;
if(!glob->use_specific_ip){
int count= 5; // no of retries for tryBind
while(!glob->socketServer->tryBind(glob->port, glob->interface_name)){
if (--count > 0) {
NdbSleep_MilliSleep(1000);
continue;
}
ndbout_c("Unable to setup port: %s:%d!\n"
"Please check if the port is already used,\n"
"(perhaps a ndb_mgmd is already running),\n"
"and if you are executing on the correct computer",
(glob->interface_name ? glob->interface_name : "*"), glob->port);
goto error_end;
}
free(glob->interface_name);
glob->interface_name = 0;
}
if(!glob->socketServer->setup(mapi, &glob->port, glob->interface_name))
{
ndbout_c("Unable to setup management port: %d!\n"
"Please check if the port is already used,\n"
"(perhaps a ndb_mgmd is already running),\n"
"and if you are executing on the correct computer",
glob->port);
delete mapi;
goto error_end;
}
if(!glob->mgmObject->check_start()){
ndbout_c("Unable to check start management server.");
ndbout_c("Probably caused by illegal initial configuration file.");
goto error_end;
}
if (opt_daemon) {
// Become a daemon
char *lockfile= NdbConfig_PidFileName(glob->localNodeId);
char *logfile= NdbConfig_StdoutFileName(glob->localNodeId);
NdbAutoPtr<char> tmp_aptr1(lockfile), tmp_aptr2(logfile);
if (NdbDaemon_Make(lockfile, logfile, 0) == -1) {
ndbout << "Cannot become daemon: " << NdbDaemon_ErrorText << endl;
return 1;
}
}
#ifndef NDB_WIN32
signal(SIGPIPE, SIG_IGN);
#endif
{
BaseString error_string;
if(!glob->mgmObject->start(error_string)){
ndbout_c("Unable to start management server.");
ndbout_c("Probably caused by illegal initial configuration file.");
ndbout_c(error_string.c_str());
goto error_end;
}
}
//glob->mgmObject->saveConfig();
mapi->setMgm(glob->mgmObject);
char msg[256];
BaseString::snprintf(msg, sizeof(msg),
"NDB Cluster Management Server. %s", NDB_VERSION_STRING);
ndbout_c(msg);
g_eventLogger.info(msg);
BaseString::snprintf(msg, 256, "Id: %d, Command port: %d",
glob->localNodeId, glob->port);
ndbout_c(msg);
g_eventLogger.info(msg);
g_StopServer = false;
g_RestartServer= false;
glob->socketServer->startServer();
#if ! defined NDB_OSE && ! defined NDB_SOFTOSE
if(opt_interactive) {
BaseString con_str;
if(glob->interface_name)
con_str.appfmt("host=%s:%d", glob->interface_name, glob->port);
else
con_str.appfmt("localhost:%d", glob->port);
Ndb_mgmclient com(con_str.c_str(), 1);
while(g_StopServer != true && read_and_execute(&com, "ndb_mgm> ", 1));
} else
#endif
{
while(g_StopServer != true)
NdbSleep_MilliSleep(500);
}
if(g_RestartServer)
g_eventLogger.info("Restarting server...");
else
g_eventLogger.info("Shutting down server...");
glob->socketServer->stopServer();
// We disconnect from the ConfigRetreiver mgmd when we delete glob below
glob->socketServer->stopSessions(true);
g_eventLogger.info("Shutdown complete");
the_end:
delete glob;
if(g_RestartServer)
goto start;
ndb_end(opt_endinfo ? MY_CHECK_ERROR | MY_GIVE_INFO : 0);
return 0;
error_end:
delete glob;
ndb_end(opt_endinfo ? MY_CHECK_ERROR | MY_GIVE_INFO : 0);
return 1;
}
int main(int argc, char** argv) {
NDB_INIT(argv[0]);
load_defaults("my",load_default_groups,&argc,&argv);
const char* _tabname;
int ho_error;
#ifndef DBUG_OFF
opt_debug= "d:t:O,/tmp/ndb_select_all.trace";
#endif
if ((ho_error=handle_options(&argc, &argv, my_long_options,
ndb_std_get_one_option)))
return NDBT_ProgramExit(NDBT_WRONGARGS);
if ((_tabname = argv[0]) == 0) {
usage();
return NDBT_ProgramExit(NDBT_WRONGARGS);
}
Ndb_cluster_connection con(opt_connect_str);
con.set_name("ndb_select_all");
if(con.connect(12, 5, 1) != 0)
{
ndbout << "Unable to connect to management server." << endl;
return NDBT_ProgramExit(NDBT_FAILED);
}
if (con.wait_until_ready(30,0) < 0)
{
ndbout << "Cluster nodes not ready in 30 seconds." << endl;
return NDBT_ProgramExit(NDBT_FAILED);
}
Ndb MyNdb(&con, _dbname );
if(MyNdb.init() != 0) {
ERR(MyNdb.getNdbError());
return NDBT_ProgramExit(NDBT_FAILED);
}
// Check if table exists in db
const NdbDictionary::Table* pTab = NDBT_Table::discoverTableFromDb(&MyNdb, _tabname);
const NdbDictionary::Index * pIdx = 0;
if(argc > 1) {
pIdx = MyNdb.getDictionary()->getIndex(argv[1], _tabname);
}
if(pTab == NULL) {
ndbout << " Table " << _tabname << " does not exist!" << endl;
return NDBT_ProgramExit(NDBT_WRONGARGS);
}
if(argc > 1 && pIdx == 0)
{
ndbout << " Index " << argv[1] << " does not exists" << endl;
}
if(_order && pIdx == NULL) {
ndbout << " Order flag given without an index" << endl;
return NDBT_ProgramExit(NDBT_WRONGARGS);
}
if (_descending && ! _order) {
ndbout << " Descending flag given without order flag" << endl;
return NDBT_ProgramExit(NDBT_WRONGARGS);
}
if (scanReadRecords(&MyNdb,
pTab,
pIdx,
_parallelism,
_lock,
_header,
_useHexFormat,
(char)*_delimiter, _order, _descending) != 0) {
return NDBT_ProgramExit(NDBT_FAILED);
}
return NDBT_ProgramExit(NDBT_OK);
}
int
main(int argc, char** argv)
{
NDB_INIT(argv[0]);
const char *load_default_groups[]= { "mysql_cluster",0 };
load_defaults("my",load_default_groups,&argc,&argv);
int ho_error;
#ifndef DBUG_OFF
opt_debug= "d:t:F:L";
#endif
if ((ho_error=handle_options(&argc, &argv, my_long_options,
ndb_std_get_one_option)))
return NDBT_ProgramExit(NDBT_WRONGARGS);
DBUG_ENTER("main");
Ndb_cluster_connection con(opt_connect_str);
if(con.connect(12, 5, 1))
{
DBUG_RETURN(NDBT_ProgramExit(NDBT_FAILED));
}
Ndb ndb(&con,_dbname);
ndb.init();
while (ndb.waitUntilReady() != 0);
NdbDictionary::Dictionary * dict = ndb.getDictionary();
int no_error= 1;
int i;
// create all tables
Vector<const NdbDictionary::Table*> pTabs;
if (argc == 0)
{
NDBT_Tables::dropAllTables(&ndb);
NDBT_Tables::createAllTables(&ndb);
for (i= 0; no_error && i < NDBT_Tables::getNumTables(); i++)
{
const NdbDictionary::Table *pTab= dict->getTable(NDBT_Tables::getTable(i)->getName());
if (pTab == 0)
{
ndbout << "Failed to create table" << endl;
ndbout << dict->getNdbError() << endl;
no_error= 0;
break;
}
pTabs.push_back(pTab);
}
}
else
{
for (i= 0; no_error && argc; argc--, i++)
{
dict->dropTable(argv[i]);
NDBT_Tables::createTable(&ndb, argv[i]);
const NdbDictionary::Table *pTab= dict->getTable(argv[i]);
if (pTab == 0)
{
ndbout << "Failed to create table" << endl;
ndbout << dict->getNdbError() << endl;
no_error= 0;
break;
}
pTabs.push_back(pTab);
}
}
pTabs.push_back(NULL);
// create an event for each table
for (i= 0; no_error && pTabs[i]; i++)
{
HugoTransactions ht(*pTabs[i]);
if (ht.createEvent(&ndb)){
no_error= 0;
break;
}
}
// create an event operation for each event
Vector<NdbEventOperation *> pOps;
for (i= 0; no_error && pTabs[i]; i++)
{
char buf[1024];
sprintf(buf, "%s_EVENT", pTabs[i]->getName());
NdbEventOperation *pOp= ndb.createEventOperation(buf, 1000);
if ( pOp == NULL )
{
no_error= 0;
break;
}
pOps.push_back(pOp);
}
// get storage for each event operation
for (i= 0; no_error && pTabs[i]; i++)
{
int n_columns= pTabs[i]->getNoOfColumns();
for (int j = 0; j < n_columns; j++) {
pOps[i]->getValue(pTabs[i]->getColumn(j)->getName());
pOps[i]->getPreValue(pTabs[i]->getColumn(j)->getName());
}
}
// start receiving events
for (i= 0; no_error && pTabs[i]; i++)
{
if ( pOps[i]->execute() )
{
no_error= 0;
break;
}
}
// create a "shadow" table for each table
Vector<const NdbDictionary::Table*> pShadowTabs;
for (i= 0; no_error && pTabs[i]; i++)
{
char buf[1024];
sprintf(buf, "%s_SHADOW", pTabs[i]->getName());
dict->dropTable(buf);
if (dict->getTable(buf))
{
no_error= 0;
break;
}
NdbDictionary::Table table_shadow(*pTabs[i]);
table_shadow.setName(buf);
dict->createTable(table_shadow);
pShadowTabs.push_back(dict->getTable(buf));
if (!pShadowTabs[i])
{
no_error= 0;
break;
}
}
// create a hugo operation per table
Vector<HugoOperations *> hugo_ops;
for (i= 0; no_error && pTabs[i]; i++)
{
hugo_ops.push_back(new HugoOperations(*pTabs[i]));
}
int n_records= 3;
// insert n_records records per table
do {
if (start_transaction(&ndb, hugo_ops))
{
no_error= 0;
break;
}
for (i= 0; no_error && pTabs[i]; i++)
{
hugo_ops[i]->pkInsertRecord(&ndb, 0, n_records);
}
if (execute_commit(&ndb, hugo_ops))
{
no_error= 0;
break;
}
if(close_transaction(&ndb, hugo_ops))
{
no_error= 0;
break;
}
} while(0);
// copy events and verify
do {
if (copy_events(&ndb) < 0)
{
no_error= 0;
break;
}
if (verify_copy(&ndb, pTabs, pShadowTabs))
{
no_error= 0;
break;
}
} while (0);
// update n_records-1 records in first table
do {
if (start_transaction(&ndb, hugo_ops))
{
no_error= 0;
break;
}
hugo_ops[0]->pkUpdateRecord(&ndb, n_records-1);
if (execute_commit(&ndb, hugo_ops))
{
no_error= 0;
break;
}
if(close_transaction(&ndb, hugo_ops))
{
no_error= 0;
break;
}
} while(0);
// copy events and verify
do {
if (copy_events(&ndb) < 0)
{
no_error= 0;
break;
}
if (verify_copy(&ndb, pTabs, pShadowTabs))
{
no_error= 0;
break;
}
} while (0);
{
NdbRestarts restarts;
for (int j= 0; j < 10; j++)
{
// restart a node
if (no_error)
{
int timeout = 240;
if (restarts.executeRestart("RestartRandomNodeAbort", timeout))
{
no_error= 0;
break;
}
}
// update all n_records records on all tables
if (start_transaction(&ndb, hugo_ops))
{
no_error= 0;
break;
}
for (int r= 0; r < n_records; r++)
{
for (i= 0; pTabs[i]; i++)
{
hugo_ops[i]->pkUpdateRecord(&ndb, r);
}
}
if (execute_commit(&ndb, hugo_ops))
{
no_error= 0;
break;
}
if(close_transaction(&ndb, hugo_ops))
{
no_error= 0;
break;
}
// copy events and verify
if (copy_events(&ndb) < 0)
{
no_error= 0;
break;
}
if (verify_copy(&ndb, pTabs, pShadowTabs))
{
no_error= 0;
break;
}
}
}
// drop the event operations
for (i= 0; i < (int)pOps.size(); i++)
{
if (ndb.dropEventOperation(pOps[i]))
{
no_error= 0;
}
}
if (no_error)
DBUG_RETURN(NDBT_ProgramExit(NDBT_OK));
DBUG_RETURN(NDBT_ProgramExit(NDBT_FAILED));
}
int main(int argc, char** argv) {
NDB_INIT(argv[0]);
load_defaults("my",load_default_groups,&argc,&argv);
int ho_error;
#ifndef DBUG_OFF
opt_debug= "d:t:O,/tmp/ndb_mgm.trace";
#endif
if ((ho_error=handle_options(&argc, &argv, my_long_options,
ndb_std_get_one_option)))
exit(ho_error);
char buf[MAXHOSTNAMELEN+10];
if(argc == 1) {
BaseString::snprintf(buf, sizeof(buf), "%s", argv[0]);
opt_connect_str= buf;
} else if (argc >= 2) {
BaseString::snprintf(buf, sizeof(buf), "%s:%s", argv[0], argv[1]);
opt_connect_str= buf;
}
if (!isatty(0) || opt_execute_str)
{
prompt= 0;
}
signal(SIGPIPE, handler);
com = new Ndb_mgmclient(opt_connect_str,1);
int ret= 0;
BaseString histfile;
if (!opt_execute_str)
{
#ifdef HAVE_READLINE
char *histfile_env= getenv("NDB_MGM_HISTFILE");
if (histfile_env)
histfile.assign(histfile_env,strlen(histfile_env));
else if(getenv("HOME"))
{
histfile.assign(getenv("HOME"),strlen(getenv("HOME")));
histfile.append("/.ndb_mgm_history");
}
if (histfile.length())
read_history(histfile.c_str());
#endif
ndbout << "-- NDB Cluster -- Management Client --" << endl;
while(read_and_execute(_try_reconnect));
#ifdef HAVE_READLINE
if (histfile.length())
{
BaseString histfile_tmp;
histfile_tmp.assign(histfile);
histfile_tmp.append(".TMP");
if(!write_history(histfile_tmp.c_str()))
my_rename(histfile_tmp.c_str(), histfile.c_str(), MYF(MY_WME));
}
#endif
}
else
{
com->execute(opt_execute_str,_try_reconnect, 0, &ret);
}
delete com;
ndb_end(opt_endinfo ? MY_CHECK_ERROR | MY_GIVE_INFO : 0);
return ret;
}
int main(int argc, char** argv){
NDB_INIT(argv[0]);
ndb_opt_set_usage_funcs(short_usage_sub, usage);
ndb_load_defaults(NULL, load_default_groups, &argc, &argv);
int ho_error;
if ((ho_error=handle_options(&argc, &argv, my_long_options,
ndb_std_get_one_option)))
return -1;
// Connect to Ndb
Ndb_cluster_connection con;
if(con.connect(12, 5, 1) != 0)
{
return NDBT_ProgramExit(NDBT_FAILED);
}
if (con.wait_until_ready(30,0) < 0)
{
ndbout << "Cluster nodes not ready in 30 seconds." << endl;
return NDBT_ProgramExit(NDBT_FAILED);
}
Ndb MyNdb( &con, _db);
if(MyNdb.init() != 0)
{
NDB_ERR(MyNdb.getNdbError());
return NDBT_ProgramExit(NDBT_FAILED);
}
Vector<const NdbDictionary::Table*> tables;
for(int i = 0; i<argc; i++)
{
const char* _tabname = argv[i];
// Check if table exists in db
const NdbDictionary::Table* pTab =
NDBT_Table::discoverTableFromDb(&MyNdb, _tabname);
if(pTab == NULL)
{
ndbout << " Table " << _tabname << " does not exist!" << endl;
return NDBT_ProgramExit(NDBT_WRONGARGS);
}
else
{
ndbout << " Discovered " << _tabname << endl;
}
tables.push_back(pTab);
}
tables.push_back(0);
HugoQueryBuilder::OptionMask mask = 0;
struct { const char * name; HugoQueryBuilder::QueryOption option; }
_ops[] = {
{ "lookup", HugoQueryBuilder::O_LOOKUP },
{ "scan", HugoQueryBuilder::O_SCAN },
{ "pk", HugoQueryBuilder::O_PK_INDEX },
{ "uk", HugoQueryBuilder::O_UNIQUE_INDEX },
{ "oi", HugoQueryBuilder::O_ORDERED_INDEX },
{ "ts", HugoQueryBuilder::O_TABLE_SCAN },
// end-marker
{ 0, HugoQueryBuilder::O_LOOKUP }
};
Vector<BaseString> list;
BaseString tmp(_options);
tmp.split(list, ",");
for (unsigned i = 0; i<list.size(); i++)
{
bool found = false;
for (int o = 0; _ops[o].name != 0; o++)
{
if (strcasecmp(list[i].c_str(), _ops[o].name) == 0)
{
found = true;
mask |= _ops[o].option;
break;
}
}
if (!found)
{
ndbout << "Unknown option " << list[i].c_str() << ", ignoring" << endl;
}
}
if (_seed == 0)
{
_seed = (unsigned)NdbTick_CurrentMillisecond();
}
ndbout << "--seed=" << _seed << endl;
srand(_seed);
for (int i = 0; (_loops == 0) || (i < _loops);)
{
if (_verbose >= 1)
{
ndbout << "******\tbuilding new query (mask: 0x" << hex
<< (Uint64)mask << ")" << endl;
}
HugoQueryBuilder builder(&MyNdb, tables.getBase(), mask);
builder.setJoinLevel(_depth);
const NdbQueryDef * q = builder.createQuery();
if (_verbose >= 2)
{
q->print(); ndbout << endl;
}
for (int j = 0; j < _loops_per_query && ((_loops == 0) || (i < _loops));
i++, j++)
{
int res = 0;
HugoQueries hq(* q);
if (q->isScanQuery())
{
res = hq.runScanQuery(&MyNdb);
}
else
{
res = hq.runLookupQuery(&MyNdb, _records/_depth, _batch);
}
if (res != 0)
{
return NDBT_ProgramExit(NDBT_FAILED);
}
if (hq.m_rows_found.size() != 0)
{
printf("\tfound: [ ");
for (unsigned i = 0; i<hq.m_rows_found.size(); i++)
{
printf("%u ", (Uint32)hq.m_rows_found[i]);
}
ndbout_c("]");
}
}
}
return NDBT_ProgramExit(NDBT_OK);
}
int main(int argc, char** argv){
NDB_INIT(argv[0]);
const char *load_default_groups[]= { "mysql_cluster",0 };
load_defaults("my",load_default_groups,&argc,&argv);
int ho_error;
#ifndef DBUG_OFF
opt_debug= "d:t:O,/tmp/ndb_desc.trace";
#endif
if ((ho_error=handle_options(&argc, &argv, my_long_options,
ndb_std_get_one_option)))
return NDBT_ProgramExit(NDBT_WRONGARGS);
for (int i = 0; i<_loop; i++)
{
Ndb_cluster_connection con(opt_connect_str);
if(con.connect(12, 5, 1) != 0)
{
ndbout << "Unable to connect to management server." << endl;
return NDBT_ProgramExit(NDBT_FAILED);
}
if (con.wait_until_ready(30,30) != 0)
{
ndbout << "Cluster nodes not ready in 30 seconds." << endl;
return NDBT_ProgramExit(NDBT_FAILED);
}
Ndb MyNdb(&con, "TEST_DB");
if(MyNdb.init() != 0){
ERR(MyNdb.getNdbError());
return NDBT_ProgramExit(NDBT_FAILED);
}
Vector<NdbEventOperation*> ops;
const NdbDictionary::Dictionary * dict= MyNdb.getDictionary();
for (int j = 0; j < argc; j++)
{
const NdbDictionary::Table * pTab = dict->getTable(argv[j]);
if (pTab == 0)
{
ndbout_c("Failed to retreive table: \"%s\"", argv[j]);
}
BaseString tmp;
tmp.appfmt("EV-%s", argv[j]);
NdbEventOperation* pOp = MyNdb.createEventOperation(tmp.c_str());
if ( pOp == NULL )
{
ndbout << "Event operation creation failed: " <<
MyNdb.getNdbError() << endl;
return NDBT_ProgramExit(NDBT_FAILED);
}
for (int a = 0; a < pTab->getNoOfColumns(); a++)
{
pOp->getValue(pTab->getColumn(a)->getName());
pOp->getPreValue(pTab->getColumn(a)->getName());
}
if (pOp->execute())
{
ndbout << "operation execution failed: " << pOp->getNdbError()
<< endl;
return NDBT_ProgramExit(NDBT_FAILED);
}
ops.push_back(pOp);
}
if (_sleep)
{
NdbSleep_MilliSleep(10 + rand() % _sleep);
}
for (Uint32 i = 0; i<ops.size(); i++)
{
switch(_drop){
case 0:
break;
do_drop:
case 1:
if (MyNdb.dropEventOperation(ops[i]))
{
ndbout << "drop event operation failed "
<< MyNdb.getNdbError() << endl;
return NDBT_ProgramExit(NDBT_FAILED);
}
break;
default:
if ((rand() % 100) > 50)
goto do_drop;
}
}
}
return NDBT_ProgramExit(NDBT_OK);
}
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);
int ho_error;
#ifndef DBUG_OFF
opt_debug= "d:t:O,/tmp/ndb_mgm.trace";
#endif
if ((ho_error=handle_options(&argc, &argv, my_long_options,
ndb_std_get_one_option)))
exit(ho_error);
BaseString connect_str(opt_ndb_connectstring);
if(argc == 1) {
connect_str.assfmt("%s", argv[0]);
} else if (argc >= 2) {
connect_str.assfmt("%s:%s", argv[0], argv[1]);
}
if (!isatty(0) || opt_execute_str)
{
prompt= 0;
}
com = new Ndb_mgmclient(connect_str.c_str(), opt_verbose);
int ret= 0;
BaseString histfile;
if (!opt_execute_str)
{
#ifdef HAVE_READLINE
char *histfile_env= getenv("NDB_MGM_HISTFILE");
if (histfile_env)
histfile.assign(histfile_env,strlen(histfile_env));
else if(getenv("HOME"))
{
histfile.assign(getenv("HOME"),strlen(getenv("HOME")));
histfile.append("/.ndb_mgm_history");
}
if (histfile.length())
read_history(histfile.c_str());
#endif
ndbout << "-- NDB Cluster -- Management Client --" << endl;
while(read_and_execute(opt_try_reconnect))
;
#ifdef HAVE_READLINE
if (histfile.length())
{
BaseString histfile_tmp;
histfile_tmp.assign(histfile);
histfile_tmp.append(".TMP");
if(!write_history(histfile_tmp.c_str()))
my_rename(histfile_tmp.c_str(), histfile.c_str(), MYF(MY_WME));
}
#endif
}
else
{
com->execute(opt_execute_str, opt_try_reconnect, 0, &ret);
}
delete com;
ndb_end(opt_ndb_endinfo ? MY_CHECK_ERROR | MY_GIVE_INFO : 0);
// Don't allow negative return code
if (ret < 0)
ret = 255;
return ret;
}
static int mgmd_main(int argc, char** argv)
{
NDB_INIT(argv[0]);
printf("MySQL Cluster Management Server %s\n", NDB_VERSION_STRING);
ndb_opt_set_usage_funcs(short_usage_sub, usage);
load_defaults("my",load_default_groups,&argc,&argv);
defaults_argv= argv; /* Must be freed by 'free_defaults' */
int ho_error;
#ifndef DBUG_OFF
opt_debug= IF_WIN("d:t:i:F:o,c:\\ndb_mgmd.trace",
"d:t:i:F:o,/tmp/ndb_mgmd.trace");
#endif
if ((ho_error=handle_options(&argc, &argv, my_long_options,
ndb_std_get_one_option)))
mgmd_exit(ho_error);
if (opts.interactive ||
opts.non_interactive ||
opts.print_full_config) {
opts.daemon= 0;
}
if (opts.mycnf && opts.config_filename)
{
fprintf(stderr, "ERROR: Both --mycnf and -f is not supported\n");
mgmd_exit(1);
}
if (opt_nowait_nodes)
{
int res = parse_mask(opt_nowait_nodes, opts.nowait_nodes);
if(res == -2 || (res > 0 && opts.nowait_nodes.get(0)))
{
fprintf(stderr, "ERROR: Invalid nodeid specified in nowait-nodes: '%s'\n",
opt_nowait_nodes);
mgmd_exit(1);
}
else if (res < 0)
{
fprintf(stderr, "ERROR: Unable to parse nowait-nodes argument: '%s'\n",
opt_nowait_nodes);
mgmd_exit(1);
}
}
/* Setup use of event logger */
g_eventLogger->setCategory(opt_logname);
/* Output to console initially */
g_eventLogger->createConsoleHandler();
#ifdef _WIN32
/* Output to Windows event log */
g_eventLogger->createEventLogHandler("MySQL Cluster Management Server");
#endif
if (opts.verbose)
g_eventLogger->enable(Logger::LL_ALL); // --verbose turns on everything
/**
Install signal handler for SIGPIPE
Done in TransporterFacade as well.. what about Configretriever?
*/
#if !defined NDB_WIN32
signal(SIGPIPE, SIG_IGN);
#endif
while (!g_StopServer)
{
mgm= new MgmtSrvr(opts);
if (mgm == NULL) {
g_eventLogger->critical("Out of memory, couldn't create MgmtSrvr");
mgmd_exit(1);
}
/* Init mgm, load or fetch config */
if (!mgm->init()) {
delete mgm;
mgmd_exit(1);
}
if (NdbDir::chdir(NdbConfig_get_path(NULL)) != 0)
{
g_eventLogger->warning("Cannot change directory to '%s', error: %d",
NdbConfig_get_path(NULL), errno);
// Ignore error
}
if (opts.daemon)
{
NodeId localNodeId= mgm->getOwnNodeId();
if (localNodeId == 0) {
g_eventLogger->error("Couldn't get own node id");
delete mgm;
mgmd_exit(1);
}
char *lockfile= NdbConfig_PidFileName(localNodeId);
char *logfile= NdbConfig_StdoutFileName(localNodeId);
if (ndb_daemonize(lockfile, logfile))
{
g_eventLogger->error("Couldn't start as daemon, error: '%s'",
ndb_daemon_error);
mgmd_exit(1);
}
}
/* Start mgm services */
if (!mgm->start()) {
delete mgm;
mgmd_exit(1);
}
if (opts.interactive) {
int port= mgm->getPort();
BaseString con_str;
if(opts.bind_address)
con_str.appfmt("host=%s:%d", opts.bind_address, port);
else
con_str.appfmt("localhost:%d", port);
Ndb_mgmclient com(con_str.c_str(), 1);
while(!g_StopServer) {
if (!read_and_execute(&com, "ndb_mgm> ", 1))
g_StopServer = true;
}
}
else
{
g_eventLogger->info("MySQL Cluster Management Server %s started",
NDB_VERSION_STRING);
while (!g_StopServer)
NdbSleep_MilliSleep(500);
}
g_eventLogger->info("Shutting down server...");
delete mgm;
g_eventLogger->info("Shutdown complete");
if(g_RestartServer) {
g_eventLogger->info("Restarting server...");
g_RestartServer= g_StopServer= false;
}
}
mgmd_exit(0);
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
main(int argc, char** argv){
NDB_INIT(argv[0]);
load_defaults("my",load_default_groups,&argc,&argv);
int ho_error;
if ((ho_error=handle_options(&argc, &argv, my_long_options,
ndb_std_get_one_option)))
return -1;
if (g_nodes && g_connections)
{
fprintf(stderr,
"Only one option of --nodes and --connections allowed\n");
return -1;
}
g_section = CFG_SECTION_NODE; //default
if (g_connections)
g_section = CFG_SECTION_CONNECTION;
ndb_mgm_configuration * conf = 0;
if (g_config_file || g_mycnf)
conf = load_configuration();
else
conf = fetch_configuration();
if (conf == 0)
{
return -1;
}
Vector<Apply*> select_list;
Vector<Match*> where_clause;
if(strcmp(g_row_delimiter, "\\n") == 0)
g_row_delimiter = "\n";
if(strcmp(g_field_delimiter, "\\n") == 0)
g_field_delimiter = "\n";
if(parse_query(select_list, argc, argv))
{
exit(0);
}
if(parse_where(where_clause, argc, argv))
{
exit(0);
}
Iter iter(* conf, g_section);
bool prev= false;
iter.first();
for(iter.first(); iter.valid(); iter.next())
{
if(eval(iter, where_clause))
{
if(prev)
printf("%s", g_row_delimiter);
prev= true;
apply(iter, select_list);
}
}
printf("\n");
return 0;
}
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;
}