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("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)
{
my_progname = "ndb_pack_frm";
int ret;
ndb_init();
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)
return NDBT_WRONGARGS;
for (int i = 0; i < argc; i++)
{
ret = dofile(argv[i]);
if (ret != 0)
return NDBT_FAILED;
}
return NDBT_OK;
}
int
main(int argc, char** argv)
{
my_progname = "ndb_index_stat";
int ret;
ndb_init();
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(_verbose ? 2 : 0);
unsigned seed = (unsigned)time(0);
g_info << "random seed " << seed << endl;
ndb_srand(seed);
ret = doall();
if (ret == -1)
return NDBT_ProgramExit(NDBT_FAILED);
return NDBT_ProgramExit(NDBT_OK);
}
int main(int argc, char** argv){
NDB_INIT(argv[0]);
const char* _tabname;
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_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_ndb_connectstring,
opt_ndb_nodeid);
if (ndb_cluster_connection == NULL)
fatal("Unable to create cluster connection");
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 NDBT_TestSuite::execute(int argc, const char** argv){
int res = NDBT_FAILED;
/* Arguments:
Run only a subset of tests
-n testname Which test to run
Recommendations to test functions:
--records Number of records to use(default: 10000)
--loops Number of loops to execute in the test(default: 100)
Other parameters should:
* be calculated from the above two parameters
* be divided into different test cases, ex. one testcase runs
with FragmentType = Single and another perfoms the same
test with FragmentType = Large
* let the test case iterate over all/subset of appropriate parameters
ex. iterate over FragmentType = Single to FragmentType = AllLarge
Remeber that the intention is that it should be _easy_ to run
a complete test suite without any greater knowledge of what
should be tested ie. keep arguments at a minimum
*/
char **_argv= (char **)argv;
if (!my_progname)
my_progname= _argv[0];
ndb_opt_set_usage_funcs(short_usage_sub, usage);
ndb_load_defaults(NULL, load_default_groups,&argc,&_argv);
// Save pointer to memory allocated by 'ndb_load_defaults'
char** defaults_argv= _argv;
int ho_error;
#ifndef DBUG_OFF
opt_debug= "d:t:i:F:L";
#endif
if ((ho_error=handle_options(&argc, &_argv, my_long_options,
ndb_std_get_one_option)))
{
usage();
ndb_free_defaults(defaults_argv);
return NDBT_ProgramExit(NDBT_WRONGARGS);
}
if (opt_verbose)
setOutputLevel(2); // Show g_info
else
setOutputLevel(0); // Show only g_err ?
records = opt_records;
loops = opt_loops;
timer = opt_timer;
if (opt_nologging)
setLogging(false);
temporaryTables = opt_temporary;
m_noddl = opt_noddl;
m_forceShort = opt_forceShort;
if (opt_seed == 0)
{
opt_seed = (unsigned)NdbTick_CurrentMillisecond();
}
ndbout_c("random seed: %u", opt_seed);
srand(opt_seed);
srandom(opt_seed);
global_flag_skip_invalidate_cache = 1;
int num_tables= argc;
if (argc == 0)
num_tables = NDBT_Tables::getNumTables();
for(int i = 0; i<num_tables; i++)
{
if (argc == 0)
m_tables_in_test.push_back(NDBT_Tables::getTable(i)->getName());
else
m_tables_in_test.push_back(_argv[i]);
}
if (m_createTable)
{
for (unsigned t = 0; t < tests.size(); t++)
{
const char* createFuncName= NULL;
NDBT_TESTFUNC* createFunc= NULL;
const char* dropFuncName= NULL;
NDBT_TESTFUNC* dropFunc= NULL;
if (!m_noddl)
{
createFuncName= m_createAll ? "runCreateTable" : "runCreateTable";
createFunc= m_createAll ? &runCreateTables : &runCreateTable;
dropFuncName= m_createAll ? "runDropTables" : "runDropTable";
dropFunc= m_createAll ? &runDropTables : &runDropTable;
}
else
{
/* No DDL allowed, so we substitute 'do nothing' variants
* of the create + drop table test procs
*/
createFuncName= "runCheckTableExists";
createFunc= &runCheckTableExists;
dropFuncName= "runEmptyDropTable";
dropFunc= &runEmptyDropTable;
}
NDBT_TestCaseImpl1* pt= (NDBT_TestCaseImpl1*)tests[t];
NDBT_Initializer* pti =
new NDBT_Initializer(pt,
createFuncName,
*createFunc);
pt->addInitializer(pti, true);
NDBT_Finalizer* ptf =
new NDBT_Finalizer(pt,
dropFuncName,
*dropFunc);
pt->addFinalizer(ptf);
}
for (unsigned t = 0; t < explicitTests.size(); t++)
{
const char* createFuncName= NULL;
NDBT_TESTFUNC* createFunc= NULL;
const char* dropFuncName= NULL;
NDBT_TESTFUNC* dropFunc= NULL;
if (!m_noddl)
{
createFuncName= m_createAll ? "runCreateTable" : "runCreateTable";
createFunc= m_createAll ? &runCreateTables : &runCreateTable;
dropFuncName= m_createAll ? "runDropTables" : "runDropTable";
dropFunc= m_createAll ? &runDropTables : &runDropTable;
}
else
{
/* No DDL allowed, so we substitute 'do nothing' variants
* of the create + drop table test procs
*/
createFuncName= "runCheckTableExists";
createFunc= &runCheckTableExists;
dropFuncName= "runEmptyDropTable";
dropFunc= &runEmptyDropTable;
}
NDBT_TestCaseImpl1* pt= (NDBT_TestCaseImpl1*)explicitTests[t];
NDBT_Initializer* pti =
new NDBT_Initializer(pt,
createFuncName,
*createFunc);
pt->addInitializer(pti, true);
NDBT_Finalizer* ptf =
new NDBT_Finalizer(pt,
dropFuncName,
*dropFunc);
pt->addFinalizer(ptf);
}
}
if (opt_print == true){
printExecutionTree();
ndb_free_defaults(defaults_argv);
return 0;
}
if (opt_print_html == true){
printExecutionTreeHTML();
ndb_free_defaults(defaults_argv);
return 0;
}
if (opt_print_cases == true){
printCases();
ndb_free_defaults(defaults_argv);
return 0;
}
Ndb_cluster_connection con(opt_ndb_connectstring, opt_ndb_nodeid);
if(m_connect_cluster && con.connect(12, 5, 1))
{
ndb_free_defaults(defaults_argv);
return NDBT_ProgramExit(NDBT_FAILED);
}
if(argc == 0){
// No table specified
res = executeAll(con, opt_testname);
} else {
testSuiteTimer.doStart();
for(int i = 0; i<argc; i++){
executeOne(con, _argv[i], opt_testname);
}
testSuiteTimer.doStop();
res = report(opt_testname);
}
ndb_free_defaults(defaults_argv);
return NDBT_ProgramExit(res);
}
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]);
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;
}
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);
}
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;
}