Skip to content

M
MariaDB
Commit cbf40241 authored by unknown's avatar unknown
Browse files
Options

Merge dev3-127.(none):/mnt/mysql/home/ngb/mysql-5.0/bug21530 

into  dev3-127.(none):/mnt/mysql/home/ngb/mysql-5.1/mysql-5.1-bug21530


storage/ndb/src/mgmclient/CommandInterpreter.cpp:
  Adding exit error code for some methods
parents 87319043 934b9a4e
Show whitespace changes
Inline Side-by-side
Showing with 204 additions and 127 deletions
storage/ndb/src/mgmclient/CommandInterpreter.cpp
View file @ cbf40241
...@@ -61,10 +61,11 @@ class CommandInterpreter { ...@@ -61,10 +61,11 @@ class CommandInterpreter {
* command will be sent to all DB processes. * command will be sent to all DB processes.
* @param allAfterFirstToken: What the client gave after the * @param allAfterFirstToken: What the client gave after the
* first token on the command line * first token on the command line
* @return: 0 if analyseAfterFirstToken succeeds, otherwise -1
*/ */
void analyseAfterFirstToken(int processId, char* allAfterFirstTokenCstr); int analyseAfterFirstToken(int processId, char* allAfterFirstTokenCstr);
void executeCommand(Vector<BaseString> &command_list, int executeCommand(Vector<BaseString> &command_list,
unsigned command_pos, unsigned command_pos,
int *node_ids, int no_of_nodes); int *node_ids, int no_of_nodes);
/** /**
...@@ -90,42 +91,42 @@ class CommandInterpreter { ...@@ -90,42 +91,42 @@ class CommandInterpreter {
* this case "22". Each function is responsible to check the parameters * this case "22". Each function is responsible to check the parameters
* argument. * argument.
*/ */
void executeHelp(char* parameters); int executeHelp(char* parameters);
void executeShow(char* parameters); int executeShow(char* parameters);
void executeConnect(char* parameters, bool interactive); int executePurge(char* parameters);
void executePurge(char* parameters); int executeConnect(char* parameters, bool interactive);
int executeShutdown(char* parameters); int executeShutdown(char* parameters);
void executeRun(char* parameters); void executeRun(char* parameters);
void executeInfo(char* parameters); void executeInfo(char* parameters);
void executeClusterLog(char* parameters); void executeClusterLog(char* parameters);
public: public:
void executeStop(int processId, const char* parameters, bool all); int executeStop(int processId, const char* parameters, bool all);
void executeStop(Vector<BaseString> &command_list, unsigned command_pos, int executeEnterSingleUser(char* parameters);
int executeExitSingleUser(char* parameters);
int executeStart(int processId, const char* parameters, bool all);
int executeRestart(int processId, const char* parameters, bool all);
int executeLogLevel(int processId, const char* parameters, bool all);
int executeError(int processId, const char* parameters, bool all);
int executeLog(int processId, const char* parameters, bool all);
int executeLogIn(int processId, const char* parameters, bool all);
int executeLogOut(int processId, const char* parameters, bool all);
int executeLogOff(int processId, const char* parameters, bool all);
int executeTestOn(int processId, const char* parameters, bool all);
int executeTestOff(int processId, const char* parameters, bool all);
int executeSet(int processId, const char* parameters, bool all);
int executeGetStat(int processId, const char* parameters, bool all);
int executeStatus(int processId, const char* parameters, bool all);
int executeEventReporting(int processId, const char* parameters, bool all);
int executeDumpState(int processId, const char* parameters, bool all);
int executeStartBackup(char * parameters);
int executeAbortBackup(char * parameters);
int executeStop(Vector<BaseString> &command_list, unsigned command_pos,
int *node_ids, int no_of_nodes); int *node_ids, int no_of_nodes);
void executeEnterSingleUser(char* parameters); int executeRestart(Vector<BaseString> &command_list, unsigned command_pos,
void executeExitSingleUser(char* parameters);
void executeStart(int processId, const char* parameters, bool all);
void executeRestart(int processId, const char* parameters, bool all);
void executeRestart(Vector<BaseString> &command_list, unsigned command_pos,
int *node_ids, int no_of_nodes); int *node_ids, int no_of_nodes);
void executeLogLevel(int processId, const char* parameters, bool all);
void executeError(int processId, const char* parameters, bool all);
void executeLog(int processId, const char* parameters, bool all);
void executeLogIn(int processId, const char* parameters, bool all);
void executeLogOut(int processId, const char* parameters, bool all);
void executeLogOff(int processId, const char* parameters, bool all);
void executeTestOn(int processId, const char* parameters, bool all);
void executeTestOff(int processId, const char* parameters, bool all);
void executeSet(int processId, const char* parameters, bool all);
void executeGetStat(int processId, const char* parameters, bool all);
void executeStatus(int processId, const char* parameters, bool all);
void executeEventReporting(int processId, const char* parameters, bool all);
void executeDumpState(int processId, const char* parameters, bool all);
int executeStartBackup(char * parameters);
void executeAbortBackup(char * parameters);
void executeRep(char* parameters); int executeRep(char* parameters);
void executeCpc(char * parameters); void executeCpc(char * parameters);
...@@ -137,7 +138,7 @@ class CommandInterpreter { ...@@ -137,7 +138,7 @@ class CommandInterpreter {
* A execute function definition * A execute function definition
*/ */
public: public:
typedef void (CommandInterpreter::* ExecuteFunction)(int processId, typedef int (CommandInterpreter::* ExecuteFunction)(int processId,
const char * param, const char * param,
bool all); bool all);
...@@ -149,7 +150,7 @@ class CommandInterpreter { ...@@ -149,7 +150,7 @@ class CommandInterpreter {
/** /**
* *
*/ */
void executeForAll(const char * cmd, int executeForAll(const char * cmd,
ExecuteFunction fun, ExecuteFunction fun,
const char * param); const char * param);
...@@ -905,6 +906,7 @@ CommandInterpreter::execute_impl(const char *_line, bool interactive) ...@@ -905,6 +906,7 @@ CommandInterpreter::execute_impl(const char *_line, bool interactive)
char * line; char * line;
if(_line == NULL) { if(_line == NULL) {
m_error = -1;
DBUG_RETURN(false); DBUG_RETURN(false);
} }
line = my_strdup(_line,MYF(MY_WME)); line = my_strdup(_line,MYF(MY_WME));
...@@ -942,16 +944,17 @@ CommandInterpreter::execute_impl(const char *_line, bool interactive) ...@@ -942,16 +944,17 @@ CommandInterpreter::execute_impl(const char *_line, bool interactive)
if (strcasecmp(firstToken, "HELP") == 0 || if (strcasecmp(firstToken, "HELP") == 0 ||
strcasecmp(firstToken, "?") == 0) { strcasecmp(firstToken, "?") == 0) {
executeHelp(allAfterFirstToken); m_error = executeHelp(allAfterFirstToken);
DBUG_RETURN(true); DBUG_RETURN(true);
} }
else if (strcasecmp(firstToken, "CONNECT") == 0) { else if (strcasecmp(firstToken, "CONNECT") == 0) {
executeConnect(allAfterFirstToken, interactive); m_error = executeConnect(allAfterFirstToken, interactive);
DBUG_RETURN(true); DBUG_RETURN(true);
} }
else if (strcasecmp(firstToken, "SLEEP") == 0) { else if (strcasecmp(firstToken, "SLEEP") == 0) {
if (allAfterFirstToken) if (allAfterFirstToken)
sleep(atoi(allAfterFirstToken)); if (sleep(atoi(allAfterFirstToken)) != 0 )
m_error = -1;
DBUG_RETURN(true); DBUG_RETURN(true);
} }
else if((strcasecmp(firstToken, "QUIT") == 0 || else if((strcasecmp(firstToken, "QUIT") == 0 ||
...@@ -961,8 +964,10 @@ CommandInterpreter::execute_impl(const char *_line, bool interactive) ...@@ -961,8 +964,10 @@ CommandInterpreter::execute_impl(const char *_line, bool interactive)
DBUG_RETURN(false); DBUG_RETURN(false);
} }
if (!connect(interactive)) if (!connect(interactive)){
m_error = -1;
DBUG_RETURN(true); DBUG_RETURN(true);
}
if (ndb_mgm_check_connection(m_mgmsrv)) if (ndb_mgm_check_connection(m_mgmsrv))
{ {
...@@ -972,7 +977,7 @@ CommandInterpreter::execute_impl(const char *_line, bool interactive) ...@@ -972,7 +977,7 @@ CommandInterpreter::execute_impl(const char *_line, bool interactive)
if (strcasecmp(firstToken, "SHOW") == 0) { if (strcasecmp(firstToken, "SHOW") == 0) {
Guard g(m_print_mutex); Guard g(m_print_mutex);
executeShow(allAfterFirstToken); m_error = executeShow(allAfterFirstToken);
DBUG_RETURN(true); DBUG_RETURN(true);
} }
else if (strcasecmp(firstToken, "SHUTDOWN") == 0) { else if (strcasecmp(firstToken, "SHUTDOWN") == 0) {
...@@ -992,29 +997,29 @@ CommandInterpreter::execute_impl(const char *_line, bool interactive) ...@@ -992,29 +997,29 @@ CommandInterpreter::execute_impl(const char *_line, bool interactive)
else if(strcasecmp(firstToken, "ABORT") == 0 && else if(strcasecmp(firstToken, "ABORT") == 0 &&
allAfterFirstToken != NULL && allAfterFirstToken != NULL &&
strncasecmp(allAfterFirstToken, "BACKUP", sizeof("BACKUP") - 1) == 0){ strncasecmp(allAfterFirstToken, "BACKUP", sizeof("BACKUP") - 1) == 0){
executeAbortBackup(allAfterFirstToken); m_error = executeAbortBackup(allAfterFirstToken);
DBUG_RETURN(true); DBUG_RETURN(true);
} }
else if (strcasecmp(firstToken, "PURGE") == 0) { else if (strcasecmp(firstToken, "PURGE") == 0) {
executePurge(allAfterFirstToken); m_error = executePurge(allAfterFirstToken);
DBUG_RETURN(true); DBUG_RETURN(true);
} }
else if(strcasecmp(firstToken, "ENTER") == 0 && else if(strcasecmp(firstToken, "ENTER") == 0 &&
allAfterFirstToken != NULL && allAfterFirstToken != NULL &&
strncasecmp(allAfterFirstToken, "SINGLE USER MODE ", strncasecmp(allAfterFirstToken, "SINGLE USER MODE ",
sizeof("SINGLE USER MODE") - 1) == 0){ sizeof("SINGLE USER MODE") - 1) == 0){
executeEnterSingleUser(allAfterFirstToken); m_error = executeEnterSingleUser(allAfterFirstToken);
DBUG_RETURN(true); DBUG_RETURN(true);
} }
else if(strcasecmp(firstToken, "EXIT") == 0 && else if(strcasecmp(firstToken, "EXIT") == 0 &&
allAfterFirstToken != NULL && allAfterFirstToken != NULL &&
strncasecmp(allAfterFirstToken, "SINGLE USER MODE ", strncasecmp(allAfterFirstToken, "SINGLE USER MODE ",
sizeof("SINGLE USER MODE") - 1) == 0){ sizeof("SINGLE USER MODE") - 1) == 0){
executeExitSingleUser(allAfterFirstToken); m_error = executeExitSingleUser(allAfterFirstToken);
DBUG_RETURN(true); DBUG_RETURN(true);
} }
else if (strcasecmp(firstToken, "ALL") == 0) { else if (strcasecmp(firstToken, "ALL") == 0) {
analyseAfterFirstToken(-1, allAfterFirstToken); m_error = analyseAfterFirstToken(-1, allAfterFirstToken);
} else { } else {
/** /**
* First tokens should be digits, node ID's * First tokens should be digits, node ID's
...@@ -1041,20 +1046,22 @@ CommandInterpreter::execute_impl(const char *_line, bool interactive) ...@@ -1041,20 +1046,22 @@ CommandInterpreter::execute_impl(const char *_line, bool interactive)
{ {
/* No digit found */ /* No digit found */
invalid_command(_line); invalid_command(_line);
m_error = -1;
DBUG_RETURN(true); DBUG_RETURN(true);
} }
if (pos == command_list.size()) if (pos == command_list.size())
{ {
/* No command found */ /* No command found */
invalid_command(_line); invalid_command(_line);
m_error = -1;
DBUG_RETURN(true); DBUG_RETURN(true);
} }
if (no_of_nodes == 1) if (no_of_nodes == 1)
{ {
analyseAfterFirstToken(node_ids[0], allAfterFirstToken); m_error = analyseAfterFirstToken(node_ids[0], allAfterFirstToken);
DBUG_RETURN(true); DBUG_RETURN(true);
} }
executeCommand(command_list, pos, node_ids, no_of_nodes); m_error = executeCommand(command_list, pos, node_ids, no_of_nodes);
DBUG_RETURN(true); DBUG_RETURN(true);
} }
DBUG_RETURN(true); DBUG_RETURN(true);
...@@ -1088,14 +1095,15 @@ static const CommandInterpreter::CommandFunctionPair commands[] = { ...@@ -1088,14 +1095,15 @@ static const CommandInterpreter::CommandFunctionPair commands[] = {
//***************************************************************************** //*****************************************************************************
//***************************************************************************** //*****************************************************************************
void int
CommandInterpreter::analyseAfterFirstToken(int processId, CommandInterpreter::analyseAfterFirstToken(int processId,
char* allAfterFirstToken) { char* allAfterFirstToken) {
int retval = 0;
if (emptyString(allAfterFirstToken)) { if (emptyString(allAfterFirstToken)) {
ndbout << "Expected a command after " ndbout << "Expected a command after "
<< ((processId == -1) ? "ALL." : "node ID.") << endl; << ((processId == -1) ? "ALL." : "node ID.") << endl;
return; return -1;
} }
char* secondToken = strtok(allAfterFirstToken, " "); char* secondToken = strtok(allAfterFirstToken, " ");
...@@ -1114,36 +1122,39 @@ CommandInterpreter::analyseAfterFirstToken(int processId, ...@@ -1114,36 +1122,39 @@ CommandInterpreter::analyseAfterFirstToken(int processId,
if(fun == 0){ if(fun == 0){
invalid_command(secondToken); invalid_command(secondToken);
return; return -1;
} }
if(processId == -1){ if(processId == -1){
executeForAll(command, fun, allAfterSecondToken); retval = executeForAll(command, fun, allAfterSecondToken);
} else { } else {
(this->*fun)(processId, allAfterSecondToken, false); retval = (this->*fun)(processId, allAfterSecondToken, false);
} }
ndbout << endl; ndbout << endl;
return retval;
} }
void int
CommandInterpreter::executeCommand(Vector<BaseString> &command_list, CommandInterpreter::executeCommand(Vector<BaseString> &command_list,
unsigned command_pos, unsigned command_pos,
int *node_ids, int no_of_nodes) int *node_ids, int no_of_nodes)
{ {
const char *cmd= command_list[command_pos].c_str(); const char *cmd= command_list[command_pos].c_str();
int retval = 0;
if (strcasecmp("STOP", cmd) == 0) if (strcasecmp("STOP", cmd) == 0)
{ {
executeStop(command_list, command_pos+1, node_ids, no_of_nodes); retval = executeStop(command_list, command_pos+1, node_ids, no_of_nodes);
return; return retval;
} }
if (strcasecmp("RESTART", cmd) == 0) if (strcasecmp("RESTART", cmd) == 0)
{ {
executeRestart(command_list, command_pos+1, node_ids, no_of_nodes); retval = executeRestart(command_list, command_pos+1, node_ids, no_of_nodes);
return; return retval;
} }
ndbout_c("Invalid command: '%s' after multi node id list. " ndbout_c("Invalid command: '%s' after multi node id list. "
"Expected STOP or RESTART.", cmd); "Expected STOP or RESTART.", cmd);
return; return -1;
} }
/** /**
...@@ -1184,18 +1195,20 @@ get_next_nodeid(struct ndb_mgm_cluster_state *cl, ...@@ -1184,18 +1195,20 @@ get_next_nodeid(struct ndb_mgm_cluster_state *cl,
return 0; return 0;
} }
void int
CommandInterpreter::executeForAll(const char * cmd, ExecuteFunction fun, CommandInterpreter::executeForAll(const char * cmd, ExecuteFunction fun,
const char * allAfterSecondToken) const char * allAfterSecondToken)
{ {
int nodeId = 0; int nodeId = 0;
int retval = 0;
if(strcasecmp(cmd, "STOP") == 0) { if(strcasecmp(cmd, "STOP") == 0) {
ndbout_c("Executing STOP on all nodes."); ndbout_c("Executing STOP on all nodes.");
(this->*fun)(nodeId, allAfterSecondToken, true); retval = (this->*fun)(nodeId, allAfterSecondToken, true);
} else if(strcasecmp(cmd, "RESTART") == 0) { } else if(strcasecmp(cmd, "RESTART") == 0) {
ndbout_c("Executing RESTART on all nodes."); ndbout_c("Executing RESTART on all nodes.");
ndbout_c("Starting shutdown. This may take a while. Please wait..."); ndbout_c("Starting shutdown. This may take a while. Please wait...");
(this->*fun)(nodeId, allAfterSecondToken, true); retval = (this->*fun)(nodeId, allAfterSecondToken, true);
ndbout_c("Trying to start all nodes of system."); ndbout_c("Trying to start all nodes of system.");
ndbout_c("Use ALL STATUS to see the system start-up phases."); ndbout_c("Use ALL STATUS to see the system start-up phases.");
} else { } else {
...@@ -1204,12 +1217,13 @@ CommandInterpreter::executeForAll(const char * cmd, ExecuteFunction fun, ...@@ -1204,12 +1217,13 @@ CommandInterpreter::executeForAll(const char * cmd, ExecuteFunction fun,
if(cl == 0){ if(cl == 0){
ndbout_c("Unable get status from management server"); ndbout_c("Unable get status from management server");
printError(); printError();
return; return -1;
} }
NdbAutoPtr<char> ap1((char*)cl); NdbAutoPtr<char> ap1((char*)cl);
while(get_next_nodeid(cl, &nodeId, NDB_MGM_NODE_TYPE_NDB)) while(get_next_nodeid(cl, &nodeId, NDB_MGM_NODE_TYPE_NDB))
(this->*fun)(nodeId, allAfterSecondToken, true); retval = (this->*fun)(nodeId, allAfterSecondToken, true);
} }
return retval;
} }
//***************************************************************************** //*****************************************************************************
...@@ -1279,7 +1293,7 @@ CommandInterpreter::parseBlockSpecification(const char* allAfterLog, ...@@ -1279,7 +1293,7 @@ CommandInterpreter::parseBlockSpecification(const char* allAfterLog,
/***************************************************************************** /*****************************************************************************
* HELP * HELP
*****************************************************************************/ *****************************************************************************/
void int
CommandInterpreter::executeHelp(char* parameters) CommandInterpreter::executeHelp(char* parameters)
{ {
if (emptyString(parameters)) { if (emptyString(parameters)) {
...@@ -1315,9 +1329,12 @@ CommandInterpreter::executeHelp(char* parameters) ...@@ -1315,9 +1329,12 @@ CommandInterpreter::executeHelp(char* parameters)
break; break;
} }
} }
if (help_items[i].cmd == NULL) if (help_items[i].cmd == NULL){
ndbout << "No help for " << parameters << " available" << endl; ndbout << "No help for " << parameters << " available" << endl;
return -1;
} }
}
return 0;
} }
...@@ -1440,7 +1457,7 @@ print_nodes(ndb_mgm_cluster_state *state, ndb_mgm_configuration_iterator *it, ...@@ -1440,7 +1457,7 @@ print_nodes(ndb_mgm_cluster_state *state, ndb_mgm_configuration_iterator *it,
ndbout << endl; ndbout << endl;
} }
void int
CommandInterpreter::executePurge(char* parameters) CommandInterpreter::executePurge(char* parameters)
{ {
int command_ok= 0; int command_ok= 0;
...@@ -1459,7 +1476,7 @@ CommandInterpreter::executePurge(char* parameters) ...@@ -1459,7 +1476,7 @@ CommandInterpreter::executePurge(char* parameters)
if (!command_ok) { if (!command_ok) {
ndbout_c("Unexpected command, expected: PURGE STALE SESSIONS"); ndbout_c("Unexpected command, expected: PURGE STALE SESSIONS");
return; return -1;
} }
int i; int i;
...@@ -1467,7 +1484,7 @@ CommandInterpreter::executePurge(char* parameters) ...@@ -1467,7 +1484,7 @@ CommandInterpreter::executePurge(char* parameters)
if (ndb_mgm_purge_stale_sessions(m_mgmsrv, &str)) { if (ndb_mgm_purge_stale_sessions(m_mgmsrv, &str)) {
ndbout_c("Command failed"); ndbout_c("Command failed");
return; return -1;
} }
if (str) { if (str) {
ndbout_c("Purged sessions with node id's: %s", str); ndbout_c("Purged sessions with node id's: %s", str);
...@@ -1477,9 +1494,10 @@ CommandInterpreter::executePurge(char* parameters) ...@@ -1477,9 +1494,10 @@ CommandInterpreter::executePurge(char* parameters)
{ {
ndbout_c("No sessions purged"); ndbout_c("No sessions purged");
} }
return 0;
} }
void int
CommandInterpreter::executeShow(char* parameters) CommandInterpreter::executeShow(char* parameters)
{ {
int i; int i;
...@@ -1488,7 +1506,7 @@ CommandInterpreter::executeShow(char* parameters) ...@@ -1488,7 +1506,7 @@ CommandInterpreter::executeShow(char* parameters)
if(state == NULL) { if(state == NULL) {
ndbout_c("Could not get status"); ndbout_c("Could not get status");
printError(); printError();
return; return -1;
} }
NdbAutoPtr<char> ap1((char*)state); NdbAutoPtr<char> ap1((char*)state);
...@@ -1496,7 +1514,7 @@ CommandInterpreter::executeShow(char* parameters) ...@@ -1496,7 +1514,7 @@ CommandInterpreter::executeShow(char* parameters)
if(conf == 0){ if(conf == 0){
ndbout_c("Could not get configuration"); ndbout_c("Could not get configuration");
printError(); printError();
return; return -1;
} }
ndb_mgm_configuration_iterator * it; ndb_mgm_configuration_iterator * it;
...@@ -1505,7 +1523,7 @@ CommandInterpreter::executeShow(char* parameters) ...@@ -1505,7 +1523,7 @@ CommandInterpreter::executeShow(char* parameters)
if(it == 0){ if(it == 0){
ndbout_c("Unable to create config iterator"); ndbout_c("Unable to create config iterator");
ndb_mgm_destroy_configuration(conf); ndb_mgm_destroy_configuration(conf);
return; return -1;
} }
NdbAutoPtr<ndb_mgm_configuration_iterator> ptr(it); NdbAutoPtr<ndb_mgm_configuration_iterator> ptr(it);
...@@ -1539,7 +1557,7 @@ CommandInterpreter::executeShow(char* parameters) ...@@ -1539,7 +1557,7 @@ CommandInterpreter::executeShow(char* parameters)
break; break;
case NDB_MGM_NODE_TYPE_UNKNOWN: case NDB_MGM_NODE_TYPE_UNKNOWN:
ndbout << "Error: Unknown Node Type" << endl; ndbout << "Error: Unknown Node Type" << endl;
return; return -1;
} }
} }
...@@ -1550,7 +1568,7 @@ CommandInterpreter::executeShow(char* parameters) ...@@ -1550,7 +1568,7 @@ CommandInterpreter::executeShow(char* parameters)
print_nodes(state, it, "mysqld", api_nodes, NDB_MGM_NODE_TYPE_API, 0); print_nodes(state, it, "mysqld", api_nodes, NDB_MGM_NODE_TYPE_API, 0);
// ndbout << helpTextShow; // ndbout << helpTextShow;
ndb_mgm_destroy_configuration(conf); ndb_mgm_destroy_configuration(conf);
return; return 0;
} else if (strcasecmp(parameters, "PROPERTIES") == 0 || } else if (strcasecmp(parameters, "PROPERTIES") == 0 ||
strcasecmp(parameters, "PROP") == 0) { strcasecmp(parameters, "PROP") == 0) {
ndbout << "SHOW PROPERTIES is not yet implemented." << endl; ndbout << "SHOW PROPERTIES is not yet implemented." << endl;
...@@ -1567,22 +1585,29 @@ CommandInterpreter::executeShow(char* parameters) ...@@ -1567,22 +1585,29 @@ CommandInterpreter::executeShow(char* parameters)
// << endl; /* XXX */ // << endl; /* XXX */
} else { } else {
ndbout << "Invalid argument." << endl; ndbout << "Invalid argument." << endl;
return -1;
} }
return 0;
} }
void int
CommandInterpreter::executeConnect(char* parameters, bool interactive) CommandInterpreter::executeConnect(char* parameters, bool interactive)
{ {
BaseString *basestring = NULL; BaseString *basestring = NULL;
int retval;
disconnect(); disconnect();
if (!emptyString(parameters)) { if (!emptyString(parameters)) {
basestring= new BaseString(parameters); basestring= new BaseString(parameters);
m_constr= basestring->trim().c_str(); m_constr= basestring->trim().c_str();
} }
connect(interactive); if ( connect(interactive) == false ){
return -1;
}
if (basestring != NULL) if (basestring != NULL)
delete basestring; delete basestring;
return 0;
} }
//***************************************************************************** //*****************************************************************************
...@@ -1595,6 +1620,7 @@ CommandInterpreter::executeClusterLog(char* parameters) ...@@ -1595,6 +1620,7 @@ CommandInterpreter::executeClusterLog(char* parameters)
if (emptyString(parameters)) if (emptyString(parameters))
{ {
ndbout << "Missing argument." << endl; ndbout << "Missing argument." << endl;
m_error = -1;
DBUG_VOID_RETURN; DBUG_VOID_RETURN;
} }
...@@ -1610,6 +1636,7 @@ CommandInterpreter::executeClusterLog(char* parameters) ...@@ -1610,6 +1636,7 @@ CommandInterpreter::executeClusterLog(char* parameters)
if(enabled == NULL) { if(enabled == NULL) {
ndbout << "Couldn't get status" << endl; ndbout << "Couldn't get status" << endl;
printError(); printError();
m_error = -1;
DBUG_VOID_RETURN; DBUG_VOID_RETURN;
} }
...@@ -1621,6 +1648,7 @@ CommandInterpreter::executeClusterLog(char* parameters) ...@@ -1621,6 +1648,7 @@ CommandInterpreter::executeClusterLog(char* parameters)
if(enabled[0] == 0) if(enabled[0] == 0)
{ {
ndbout << "Cluster logging is disabled." << endl; ndbout << "Cluster logging is disabled." << endl;
m_error = 0;
DBUG_VOID_RETURN; DBUG_VOID_RETURN;
} }
#if 0 #if 0
...@@ -1639,6 +1667,7 @@ CommandInterpreter::executeClusterLog(char* parameters) ...@@ -1639,6 +1667,7 @@ CommandInterpreter::executeClusterLog(char* parameters)
ndbout << BaseString(str).ndb_toupper() << " "; ndbout << BaseString(str).ndb_toupper() << " ";
} }
ndbout << endl; ndbout << endl;
m_error = 0;
DBUG_VOID_RETURN; DBUG_VOID_RETURN;
} }
...@@ -1657,6 +1686,7 @@ CommandInterpreter::executeClusterLog(char* parameters) ...@@ -1657,6 +1686,7 @@ CommandInterpreter::executeClusterLog(char* parameters)
enable= 1; enable= 1;
} else { } else {
ndbout << "Invalid argument." << endl; ndbout << "Invalid argument." << endl;
m_error = -1;
DBUG_VOID_RETURN; DBUG_VOID_RETURN;
} }
...@@ -1671,9 +1701,11 @@ CommandInterpreter::executeClusterLog(char* parameters) ...@@ -1671,9 +1701,11 @@ CommandInterpreter::executeClusterLog(char* parameters)
{ {
ndbout << "Couldn't set filter" << endl; ndbout << "Couldn't set filter" << endl;
printError(); printError();
m_error = -1;
DBUG_VOID_RETURN; DBUG_VOID_RETURN;
} }
ndbout << "Cluster logging is " << (res_enable ? "enabled.":"disabled") << endl; ndbout << "Cluster logging is " << (res_enable ? "enabled.":"disabled") << endl;
m_error = 0;
DBUG_VOID_RETURN; DBUG_VOID_RETURN;
} }
...@@ -1700,6 +1732,7 @@ CommandInterpreter::executeClusterLog(char* parameters) ...@@ -1700,6 +1732,7 @@ CommandInterpreter::executeClusterLog(char* parameters)
} }
if (severity == NDB_MGM_ILLEGAL_EVENT_SEVERITY) { if (severity == NDB_MGM_ILLEGAL_EVENT_SEVERITY) {
ndbout << "Invalid severity level: " << item << endl; ndbout << "Invalid severity level: " << item << endl;
m_error = -1;
DBUG_VOID_RETURN; DBUG_VOID_RETURN;
} }
...@@ -1709,6 +1742,7 @@ CommandInterpreter::executeClusterLog(char* parameters) ...@@ -1709,6 +1742,7 @@ CommandInterpreter::executeClusterLog(char* parameters)
{ {
ndbout << "Couldn't set filter" << endl; ndbout << "Couldn't set filter" << endl;
printError(); printError();
m_error = -1;
DBUG_VOID_RETURN; DBUG_VOID_RETURN;
} }
ndbout << BaseString(item).ndb_toupper().c_str() << " " << (res_enable ? "enabled":"disabled") << endl; ndbout << BaseString(item).ndb_toupper().c_str() << " " << (res_enable ? "enabled":"disabled") << endl;
...@@ -1716,16 +1750,19 @@ CommandInterpreter::executeClusterLog(char* parameters) ...@@ -1716,16 +1750,19 @@ CommandInterpreter::executeClusterLog(char* parameters)
item = strtok_r(NULL, " ", &tmpPtr); item = strtok_r(NULL, " ", &tmpPtr);
} while(item != NULL); } while(item != NULL);
m_error = 0;
DBUG_VOID_RETURN; DBUG_VOID_RETURN;
} }
//***************************************************************************** //*****************************************************************************
//***************************************************************************** //*****************************************************************************
void int
CommandInterpreter::executeStop(int processId, const char *parameters, CommandInterpreter::executeStop(int processId, const char *parameters,
bool all) bool all)
{ {
int retval = 0;
Vector<BaseString> command_list; Vector<BaseString> command_list;
if (parameters) if (parameters)
{ {
...@@ -1735,18 +1772,22 @@ CommandInterpreter::executeStop(int processId, const char *parameters, ...@@ -1735,18 +1772,22 @@ CommandInterpreter::executeStop(int processId, const char *parameters,
command_list[i].c_str()[0] ? i++ : (command_list.erase(i),0); command_list[i].c_str()[0] ? i++ : (command_list.erase(i),0);
} }
if (all) if (all)
executeStop(command_list, 0, 0, 0); retval = executeStop(command_list, 0, 0, 0);
else else
executeStop(command_list, 0, &processId, 1); retval = executeStop(command_list, 0, &processId, 1);
return retval;
} }
void int
CommandInterpreter::executeStop(Vector<BaseString> &command_list, CommandInterpreter::executeStop(Vector<BaseString> &command_list,
unsigned command_pos, unsigned command_pos,
int *node_ids, int no_of_nodes) int *node_ids, int no_of_nodes)
{ {
int need_disconnect; int need_disconnect;
int abort= 0; int abort= 0;
int retval = 0;
for (; command_pos < command_list.size(); command_pos++) for (; command_pos < command_list.size(); command_pos++)
{ {
const char *item= command_list[command_pos].c_str(); const char *item= command_list[command_pos].c_str();
...@@ -1757,7 +1798,7 @@ CommandInterpreter::executeStop(Vector<BaseString> &command_list, ...@@ -1757,7 +1798,7 @@ CommandInterpreter::executeStop(Vector<BaseString> &command_list,
} }
ndbout_c("Invalid option: %s. Expecting -A after STOP", ndbout_c("Invalid option: %s. Expecting -A after STOP",
item); item);
return; return -1;
} }
int result= ndb_mgm_stop3(m_mgmsrv, no_of_nodes, node_ids, abort, int result= ndb_mgm_stop3(m_mgmsrv, no_of_nodes, node_ids, abort,
...@@ -1766,6 +1807,7 @@ CommandInterpreter::executeStop(Vector<BaseString> &command_list, ...@@ -1766,6 +1807,7 @@ CommandInterpreter::executeStop(Vector<BaseString> &command_list,
{ {
ndbout_c("Shutdown failed."); ndbout_c("Shutdown failed.");
printError(); printError();
retval = -1;
} }
else else
{ {
...@@ -1786,9 +1828,10 @@ CommandInterpreter::executeStop(Vector<BaseString> &command_list, ...@@ -1786,9 +1828,10 @@ CommandInterpreter::executeStop(Vector<BaseString> &command_list,
disconnect(); disconnect();
} }
return retval;
} }
void int
CommandInterpreter::executeEnterSingleUser(char* parameters) CommandInterpreter::executeEnterSingleUser(char* parameters)
{ {
strtok(parameters, " "); strtok(parameters, " ");
...@@ -1800,37 +1843,42 @@ CommandInterpreter::executeEnterSingleUser(char* parameters) ...@@ -1800,37 +1843,42 @@ CommandInterpreter::executeEnterSingleUser(char* parameters)
if(id == 0 || sscanf(id, "%d", &nodeId) != 1){ if(id == 0 || sscanf(id, "%d", &nodeId) != 1){
ndbout_c("Invalid arguments: expected <NodeId>"); ndbout_c("Invalid arguments: expected <NodeId>");
ndbout_c("Use SHOW to see what API nodes are configured"); ndbout_c("Use SHOW to see what API nodes are configured");
return; return -1;
} }
int result = ndb_mgm_enter_single_user(m_mgmsrv, nodeId, &reply); int result = ndb_mgm_enter_single_user(m_mgmsrv, nodeId, &reply);
if (result != 0) { if (result != 0) {
ndbout_c("Entering single user mode for node %d failed", nodeId); ndbout_c("Entering single user mode for node %d failed", nodeId);
printError(); printError();
return -1;
} else { } else {
ndbout_c("Single user mode entered"); ndbout_c("Single user mode entered");
ndbout_c("Access is granted for API node %d only.", nodeId); ndbout_c("Access is granted for API node %d only.", nodeId);
} }
return 0;
} }
void int
CommandInterpreter::executeExitSingleUser(char* parameters) CommandInterpreter::executeExitSingleUser(char* parameters)
{ {
int result = ndb_mgm_exit_single_user(m_mgmsrv, 0); int result = ndb_mgm_exit_single_user(m_mgmsrv, 0);
if (result != 0) { if (result != 0) {
ndbout_c("Exiting single user mode failed."); ndbout_c("Exiting single user mode failed.");
printError(); printError();
return -1;
} else { } else {
ndbout_c("Exiting single user mode in progress."); ndbout_c("Exiting single user mode in progress.");
ndbout_c("Use ALL STATUS or SHOW to see when single user mode has been exited."); ndbout_c("Use ALL STATUS or SHOW to see when single user mode has been exited.");
return 0;
} }
} }
void int
CommandInterpreter::executeStart(int processId, const char* parameters, CommandInterpreter::executeStart(int processId, const char* parameters,
bool all) bool all)
{ {
int result; int result;
int retval = 0;
if(all) { if(all) {
result = ndb_mgm_start(m_mgmsrv, 0, 0); result = ndb_mgm_start(m_mgmsrv, 0, 0);
} else { } else {
...@@ -1840,6 +1888,7 @@ CommandInterpreter::executeStart(int processId, const char* parameters, ...@@ -1840,6 +1888,7 @@ CommandInterpreter::executeStart(int processId, const char* parameters,
if (result <= 0) { if (result <= 0) {
ndbout << "Start failed." << endl; ndbout << "Start failed." << endl;
printError(); printError();
retval = -1;
} else } else
{ {
if(all) if(all)
...@@ -1847,13 +1896,16 @@ CommandInterpreter::executeStart(int processId, const char* parameters, ...@@ -1847,13 +1896,16 @@ CommandInterpreter::executeStart(int processId, const char* parameters,
else else
ndbout_c("Database node %d is being started.", processId); ndbout_c("Database node %d is being started.", processId);
} }
return retval;
} }
void int
CommandInterpreter::executeRestart(int processId, const char* parameters, CommandInterpreter::executeRestart(int processId, const char* parameters,
bool all) bool all)
{ {
Vector<BaseString> command_list; Vector<BaseString> command_list;
int retval = 0;
if (parameters) if (parameters)
{ {
BaseString tmp(parameters); BaseString tmp(parameters);
...@@ -1862,17 +1914,20 @@ CommandInterpreter::executeRestart(int processId, const char* parameters, ...@@ -1862,17 +1914,20 @@ CommandInterpreter::executeRestart(int processId, const char* parameters,
command_list[i].c_str()[0] ? i++ : (command_list.erase(i),0); command_list[i].c_str()[0] ? i++ : (command_list.erase(i),0);
} }
if (all) if (all)
executeRestart(command_list, 0, 0, 0); retval = executeRestart(command_list, 0, 0, 0);
else else
executeRestart(command_list, 0, &processId, 1); retval = executeRestart(command_list, 0, &processId, 1);
return retval;
} }
void int
CommandInterpreter::executeRestart(Vector<BaseString> &command_list, CommandInterpreter::executeRestart(Vector<BaseString> &command_list,
unsigned command_pos, unsigned command_pos,
int *node_ids, int no_of_nodes) int *node_ids, int no_of_nodes)
{ {
int result; int result;
int retval = 0;
int nostart= 0; int nostart= 0;
int initialstart= 0; int initialstart= 0;
int abort= 0; int abort= 0;
...@@ -1898,7 +1953,7 @@ CommandInterpreter::executeRestart(Vector<BaseString> &command_list, ...@@ -1898,7 +1953,7 @@ CommandInterpreter::executeRestart(Vector<BaseString> &command_list,
} }
ndbout_c("Invalid option: %s. Expecting -A,-N or -I after RESTART", ndbout_c("Invalid option: %s. Expecting -A,-N or -I after RESTART",
item); item);
return; return -1;
} }
result= ndb_mgm_restart3(m_mgmsrv, no_of_nodes, node_ids, result= ndb_mgm_restart3(m_mgmsrv, no_of_nodes, node_ids,
...@@ -1907,6 +1962,7 @@ CommandInterpreter::executeRestart(Vector<BaseString> &command_list, ...@@ -1907,6 +1962,7 @@ CommandInterpreter::executeRestart(Vector<BaseString> &command_list,
if (result <= 0) { if (result <= 0) {
ndbout_c("Restart failed."); ndbout_c("Restart failed.");
printError(); printError();
retval = -1;
} }
else else
{ {
...@@ -1922,15 +1978,16 @@ CommandInterpreter::executeRestart(Vector<BaseString> &command_list, ...@@ -1922,15 +1978,16 @@ CommandInterpreter::executeRestart(Vector<BaseString> &command_list,
if(need_disconnect) if(need_disconnect)
disconnect(); disconnect();
} }
return retval;
} }
void int
CommandInterpreter::executeDumpState(int processId, const char* parameters, CommandInterpreter::executeDumpState(int processId, const char* parameters,
bool all) bool all)
{ {
if(emptyString(parameters)){ if(emptyString(parameters)){
ndbout << "Expected argument" << endl; ndbout << "Expected argument" << endl;
return; return -1;
} }
Uint32 no = 0; Uint32 no = 0;
...@@ -1947,7 +2004,7 @@ CommandInterpreter::executeDumpState(int processId, const char* parameters, ...@@ -1947,7 +2004,7 @@ CommandInterpreter::executeDumpState(int processId, const char* parameters,
ndbout << "Illegal value in argument to signal." << endl ndbout << "Illegal value in argument to signal." << endl
<< "(Value must be between 0 and 0xffffffff.)" << "(Value must be between 0 and 0xffffffff.)"
<< endl; << endl;
return; return -1;
} }
no++; no++;
item = strtok_r(NULL, " ", &tmpPtr); item = strtok_r(NULL, " ", &tmpPtr);
...@@ -1959,16 +2016,16 @@ CommandInterpreter::executeDumpState(int processId, const char* parameters, ...@@ -1959,16 +2016,16 @@ CommandInterpreter::executeDumpState(int processId, const char* parameters,
} }
struct ndb_mgm_reply reply; struct ndb_mgm_reply reply;
ndb_mgm_dump_state(m_mgmsrv, processId, pars, no, &reply); return ndb_mgm_dump_state(m_mgmsrv, processId, pars, no, &reply);
} }
void int
CommandInterpreter::executeStatus(int processId, CommandInterpreter::executeStatus(int processId,
const char* parameters, bool all) const char* parameters, bool all)
{ {
if (! emptyString(parameters)) { if (! emptyString(parameters)) {
ndbout_c("No parameters expected to this command."); ndbout_c("No parameters expected to this command.");
return; return -1;
} }
ndb_mgm_node_status status; ndb_mgm_node_status status;
...@@ -1980,7 +2037,7 @@ CommandInterpreter::executeStatus(int processId, ...@@ -1980,7 +2037,7 @@ CommandInterpreter::executeStatus(int processId,
if(cl == NULL) { if(cl == NULL) {
ndbout_c("Cannot get status of node %d.", processId); ndbout_c("Cannot get status of node %d.", processId);
printError(); printError();
return; return -1;
} }
NdbAutoPtr<char> ap1((char*)cl); NdbAutoPtr<char> ap1((char*)cl);
...@@ -1989,7 +2046,7 @@ CommandInterpreter::executeStatus(int processId, ...@@ -1989,7 +2046,7 @@ CommandInterpreter::executeStatus(int processId,
i++; i++;
if(cl->node_states[i].node_id != processId) { if(cl->node_states[i].node_id != processId) {
ndbout << processId << ": Node not found" << endl; ndbout << processId << ": Node not found" << endl;
return; return -1;
} }
status = cl->node_states[i].node_status; status = cl->node_states[i].node_status;
startPhase = cl->node_states[i].start_phase; startPhase = cl->node_states[i].start_phase;
...@@ -2013,27 +2070,29 @@ CommandInterpreter::executeStatus(int processId, ...@@ -2013,27 +2070,29 @@ CommandInterpreter::executeStatus(int processId,
getBuild(version)); getBuild(version));
else else
ndbout << endl; ndbout << endl;
return 0;
} }
//***************************************************************************** //*****************************************************************************
//***************************************************************************** //*****************************************************************************
void int
CommandInterpreter::executeLogLevel(int processId, const char* parameters, CommandInterpreter::executeLogLevel(int processId, const char* parameters,
bool all) bool all)
{ {
(void) all; (void) all;
if (emptyString(parameters)) { if (emptyString(parameters)) {
ndbout << "Expected argument" << endl; ndbout << "Expected argument" << endl;
return; return -1;
} }
BaseString tmp(parameters); BaseString tmp(parameters);
Vector<BaseString> spec; Vector<BaseString> spec;
tmp.split(spec, "="); tmp.split(spec, "=");
if(spec.size() != 2){ if(spec.size() != 2){
ndbout << "Invalid loglevel specification: " << parameters << endl; ndbout << "Invalid loglevel specification: " << parameters << endl;
return; return -1;
} }
spec[0].trim().ndb_toupper(); spec[0].trim().ndb_toupper();
...@@ -2043,14 +2102,14 @@ CommandInterpreter::executeLogLevel(int processId, const char* parameters, ...@@ -2043,14 +2102,14 @@ CommandInterpreter::executeLogLevel(int processId, const char* parameters,
if(category < NDB_MGM_MIN_EVENT_CATEGORY || if(category < NDB_MGM_MIN_EVENT_CATEGORY ||
category > NDB_MGM_MAX_EVENT_CATEGORY){ category > NDB_MGM_MAX_EVENT_CATEGORY){
ndbout << "Unknown category: \"" << spec[0].c_str() << "\"" << endl; ndbout << "Unknown category: \"" << spec[0].c_str() << "\"" << endl;
return; return -1;
} }
} }
int level = atoi(spec[1].c_str()); int level = atoi(spec[1].c_str());
if(level < 0 || level > 15){ if(level < 0 || level > 15){
ndbout << "Invalid level: " << spec[1].c_str() << endl; ndbout << "Invalid level: " << spec[1].c_str() << endl;
return; return -1;
} }
ndbout << "Executing LOGLEVEL on node " << processId << flush; ndbout << "Executing LOGLEVEL on node " << processId << flush;
...@@ -2066,20 +2125,22 @@ CommandInterpreter::executeLogLevel(int processId, const char* parameters, ...@@ -2066,20 +2125,22 @@ CommandInterpreter::executeLogLevel(int processId, const char* parameters,
if (result < 0) { if (result < 0) {
ndbout_c(" failed."); ndbout_c(" failed.");
printError(); printError();
return -1;
} else { } else {
ndbout_c(" OK!"); ndbout_c(" OK!");
} }
return 0;
} }
//***************************************************************************** //*****************************************************************************
//***************************************************************************** //*****************************************************************************
void CommandInterpreter::executeError(int processId, int CommandInterpreter::executeError(int processId,
const char* parameters, bool /* all */) const char* parameters, bool /* all */)
{ {
int retval = 0;
if (emptyString(parameters)) { if (emptyString(parameters)) {
ndbout << "Missing error number." << endl; ndbout << "Missing error number." << endl;
return; return -1;
} }
// Copy parameters since strtok will modify it // Copy parameters since strtok will modify it
...@@ -2090,29 +2151,30 @@ void CommandInterpreter::executeError(int processId, ...@@ -2090,29 +2151,30 @@ void CommandInterpreter::executeError(int processId,
int errorNo; int errorNo;
if (! convert(firstParameter, errorNo)) { if (! convert(firstParameter, errorNo)) {
ndbout << "Expected an integer." << endl; ndbout << "Expected an integer." << endl;
return; return -1;
} }
char* allAfterFirstParameter = strtok(NULL, "\0"); char* allAfterFirstParameter = strtok(NULL, "\0");
if (! emptyString(allAfterFirstParameter)) { if (! emptyString(allAfterFirstParameter)) {
ndbout << "Nothing expected after error number." << endl; ndbout << "Nothing expected after error number." << endl;
return; return -1;
} }
ndb_mgm_insert_error(m_mgmsrv, processId, errorNo, NULL); retval = ndb_mgm_insert_error(m_mgmsrv, processId, errorNo, NULL);
return retval;
} }
//***************************************************************************** //*****************************************************************************
//***************************************************************************** //*****************************************************************************
void int
CommandInterpreter::executeLog(int processId, CommandInterpreter::executeLog(int processId,
const char* parameters, bool all) const char* parameters, bool all)
{ {
struct ndb_mgm_reply reply; struct ndb_mgm_reply reply;
Vector<const char *> blocks; Vector<const char *> blocks;
if (! parseBlockSpecification(parameters, blocks)) { if (! parseBlockSpecification(parameters, blocks)) {
return; return -1;
} }
int len=1; int len=1;
Uint32 i; Uint32 i;
...@@ -2136,82 +2198,91 @@ CommandInterpreter::executeLog(int processId, ...@@ -2136,82 +2198,91 @@ CommandInterpreter::executeLog(int processId,
if (result != 0) { if (result != 0) {
ndbout_c("Execute LOG on node %d failed.", processId); ndbout_c("Execute LOG on node %d failed.", processId);
printError(); printError();
return -1;
} }
return 0;
} }
//***************************************************************************** //*****************************************************************************
//***************************************************************************** //*****************************************************************************
void int
CommandInterpreter::executeLogIn(int /* processId */, CommandInterpreter::executeLogIn(int /* processId */,
const char* parameters, bool /* all */) const char* parameters, bool /* all */)
{ {
ndbout << "Command LOGIN not implemented." << endl; ndbout << "Command LOGIN not implemented." << endl;
return 0;
} }
//***************************************************************************** //*****************************************************************************
//***************************************************************************** //*****************************************************************************
void int
CommandInterpreter::executeLogOut(int /*processId*/, CommandInterpreter::executeLogOut(int /*processId*/,
const char* parameters, bool /*all*/) const char* parameters, bool /*all*/)
{ {
ndbout << "Command LOGOUT not implemented." << endl; ndbout << "Command LOGOUT not implemented." << endl;
return 0;
} }
//***************************************************************************** //*****************************************************************************
//***************************************************************************** //*****************************************************************************
void int
CommandInterpreter::executeLogOff(int /*processId*/, CommandInterpreter::executeLogOff(int /*processId*/,
const char* parameters, bool /*all*/) const char* parameters, bool /*all*/)
{ {
ndbout << "Command LOGOFF not implemented." << endl; ndbout << "Command LOGOFF not implemented." << endl;
return 0;
} }
//***************************************************************************** //*****************************************************************************
//***************************************************************************** //*****************************************************************************
void int
CommandInterpreter::executeTestOn(int processId, CommandInterpreter::executeTestOn(int processId,
const char* parameters, bool /*all*/) const char* parameters, bool /*all*/)
{ {
if (! emptyString(parameters)) { if (! emptyString(parameters)) {
ndbout << "No parameters expected to this command." << endl; ndbout << "No parameters expected to this command." << endl;
return; return -1;
} }
struct ndb_mgm_reply reply; struct ndb_mgm_reply reply;
int result = ndb_mgm_start_signallog(m_mgmsrv, processId, &reply); int result = ndb_mgm_start_signallog(m_mgmsrv, processId, &reply);
if (result != 0) { if (result != 0) {
ndbout_c("Execute TESTON failed."); ndbout_c("Execute TESTON failed.");
printError(); printError();
return -1;
} }
return 0;
} }
//***************************************************************************** //*****************************************************************************
//***************************************************************************** //*****************************************************************************
void int
CommandInterpreter::executeTestOff(int processId, CommandInterpreter::executeTestOff(int processId,
const char* parameters, bool /*all*/) const char* parameters, bool /*all*/)
{ {
if (! emptyString(parameters)) { if (! emptyString(parameters)) {
ndbout << "No parameters expected to this command." << endl; ndbout << "No parameters expected to this command." << endl;
return; return -1;
} }
struct ndb_mgm_reply reply; struct ndb_mgm_reply reply;
int result = ndb_mgm_stop_signallog(m_mgmsrv, processId, &reply); int result = ndb_mgm_stop_signallog(m_mgmsrv, processId, &reply);
if (result != 0) { if (result != 0) {
ndbout_c("Execute TESTOFF failed."); ndbout_c("Execute TESTOFF failed.");
printError(); printError();
return -1;
} }
return 0;
} }
//***************************************************************************** //*****************************************************************************
//***************************************************************************** //*****************************************************************************
void int
CommandInterpreter::executeSet(int /*processId*/, CommandInterpreter::executeSet(int /*processId*/,
const char* parameters, bool /*all*/) const char* parameters, bool /*all*/)
{ {
if (emptyString(parameters)) { if (emptyString(parameters)) {
ndbout << "Missing parameter name." << endl; ndbout << "Missing parameter name." << endl;
return; return -1;
} }
#if 0 #if 0
// Copy parameters since strtok will modify it // Copy parameters since strtok will modify it
...@@ -2276,16 +2347,17 @@ CommandInterpreter::executeSet(int /*processId*/, ...@@ -2276,16 +2347,17 @@ CommandInterpreter::executeSet(int /*processId*/,
} }
} }
#endif #endif
return 0;
} }
//***************************************************************************** //*****************************************************************************
//***************************************************************************** //*****************************************************************************
void CommandInterpreter::executeGetStat(int /*processId*/, int CommandInterpreter::executeGetStat(int /*processId*/,
const char* parameters, bool /*all*/) const char* parameters, bool /*all*/)
{ {
if (! emptyString(parameters)) { if (! emptyString(parameters)) {
ndbout << "No parameters expected to this command." << endl; ndbout << "No parameters expected to this command." << endl;
return; return -1;
} }
#if 0 #if 0
...@@ -2301,19 +2373,21 @@ void CommandInterpreter::executeGetStat(int /*processId*/, ...@@ -2301,19 +2373,21 @@ void CommandInterpreter::executeGetStat(int /*processId*/,
ndbout << "Number of GETSTAT commands: " ndbout << "Number of GETSTAT commands: "
<< statistics._test1 << endl; << statistics._test1 << endl;
*/ */
return 0;
} }
//***************************************************************************** //*****************************************************************************
//***************************************************************************** //*****************************************************************************
void int
CommandInterpreter::executeEventReporting(int processId, CommandInterpreter::executeEventReporting(int processId,
const char* parameters, const char* parameters,
bool all) bool all)
{ {
int retval = 0;
if (emptyString(parameters)) { if (emptyString(parameters)) {
ndbout << "Expected argument" << endl; ndbout << "Expected argument" << endl;
return; return -1;
} }
BaseString tmp(parameters); BaseString tmp(parameters);
Vector<BaseString> specs; Vector<BaseString> specs;
...@@ -2360,10 +2434,12 @@ CommandInterpreter::executeEventReporting(int processId, ...@@ -2360,10 +2434,12 @@ CommandInterpreter::executeEventReporting(int processId,
if (result != 0) { if (result != 0) {
ndbout_c(" failed."); ndbout_c(" failed.");
printError(); printError();
retval = -1;
} else { } else {
ndbout_c(" OK!"); ndbout_c(" OK!");
} }
} }
return retval;
} }
/***************************************************************************** /*****************************************************************************
...@@ -2464,7 +2540,7 @@ CommandInterpreter::executeStartBackup(char* parameters) ...@@ -2464,7 +2540,7 @@ CommandInterpreter::executeStartBackup(char* parameters)
return 0; return 0;
} }
void int
CommandInterpreter::executeAbortBackup(char* parameters) CommandInterpreter::executeAbortBackup(char* parameters)
{ {
int bid = -1; int bid = -1;
...@@ -2483,14 +2559,15 @@ CommandInterpreter::executeAbortBackup(char* parameters) ...@@ -2483,14 +2559,15 @@ CommandInterpreter::executeAbortBackup(char* parameters)
if (result != 0) { if (result != 0) {
ndbout << "Abort of backup " << bid << " failed" << endl; ndbout << "Abort of backup " << bid << " failed" << endl;
printError(); printError();
return -1;
} else { } else {
ndbout << "Abort of backup " << bid << " ordered" << endl; ndbout << "Abort of backup " << bid << " ordered" << endl;
} }
} }
return; return 0;
executeAbortBackupError1: executeAbortBackupError1:
ndbout << "Invalid arguments: expected <BackupId>" << endl; ndbout << "Invalid arguments: expected <BackupId>" << endl;
return; return -1;
} }
template class Vector<char const*>; template class Vector<char const*>;
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7