Skip to content

M
mariadb
Commit cdacbe3f authored by gni/root@dev3-127.(none)'s avatar gni/root@dev3-127.(none)
Browse files
Options

BUG#21530 The ndb_mgm management client doesn't set the exit status on errors, making it 

          almost useless for any kind of shell script automation.
          Now add the return value that indicates the execution whether or not success 
          for many methods.
parent cb6d518d
Hide whitespace changes
Inline Side-by-side
Showing with 195 additions and 123 deletions
ndb/src/mgmclient/CommandInterpreter.cpp
View file @ cdacbe3f
...@@ -67,8 +67,9 @@ private: ...@@ -67,8 +67,9 @@ private:
* 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);
/** /**
* Parse the block specification part of the LOG* commands, * Parse the block specification part of the LOG* commands,
...@@ -93,38 +94,38 @@ private: ...@@ -93,38 +94,38 @@ private:
* 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); int executeConnect(char* parameters);
void executePurge(char* parameters); int executePurge(char* parameters);
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 executeEnterSingleUser(char* parameters); int executeEnterSingleUser(char* parameters);
void executeExitSingleUser(char* parameters); int executeExitSingleUser(char* parameters);
void executeStart(int processId, const char* parameters, bool all); int executeStart(int processId, const char* parameters, bool all);
void executeRestart(int processId, const char* parameters, bool all); int executeRestart(int processId, const char* parameters, bool all);
void executeLogLevel(int processId, const char* parameters, bool all); int executeLogLevel(int processId, const char* parameters, bool all);
void executeError(int processId, const char* parameters, bool all); int executeError(int processId, const char* parameters, bool all);
void executeLog(int processId, const char* parameters, bool all); int executeLog(int processId, const char* parameters, bool all);
void executeLogIn(int processId, const char* parameters, bool all); int executeLogIn(int processId, const char* parameters, bool all);
void executeLogOut(int processId, const char* parameters, bool all); int executeLogOut(int processId, const char* parameters, bool all);
void executeLogOff(int processId, const char* parameters, bool all); int executeLogOff(int processId, const char* parameters, bool all);
void executeTestOn(int processId, const char* parameters, bool all); int executeTestOn(int processId, const char* parameters, bool all);
void executeTestOff(int processId, const char* parameters, bool all); int executeTestOff(int processId, const char* parameters, bool all);
void executeSet(int processId, const char* parameters, bool all); int executeSet(int processId, const char* parameters, bool all);
void executeGetStat(int processId, const char* parameters, bool all); int executeGetStat(int processId, const char* parameters, bool all);
void executeStatus(int processId, const char* parameters, bool all); int executeStatus(int processId, const char* parameters, bool all);
void executeEventReporting(int processId, const char* parameters, bool all); int executeEventReporting(int processId, const char* parameters, bool all);
void executeDumpState(int processId, const char* parameters, bool all); int executeDumpState(int processId, const char* parameters, bool all);
int executeStartBackup(char * parameters); int executeStartBackup(char * parameters);
void executeAbortBackup(char * parameters); int executeAbortBackup(char * parameters);
void executeRep(char* parameters); int executeRep(char* parameters);
void executeCpc(char * parameters); void executeCpc(char * parameters);
...@@ -136,7 +137,7 @@ public: ...@@ -136,7 +137,7 @@ public:
* 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);
...@@ -148,7 +149,7 @@ private: ...@@ -148,7 +149,7 @@ private:
/** /**
* *
*/ */
void executeForAll(const char * cmd, int executeForAll(const char * cmd,
ExecuteFunction fun, ExecuteFunction fun,
const char * param); const char * param);
...@@ -606,6 +607,7 @@ CommandInterpreter::execute_impl(const char *_line) ...@@ -606,6 +607,7 @@ CommandInterpreter::execute_impl(const char *_line)
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));
...@@ -636,16 +638,17 @@ CommandInterpreter::execute_impl(const char *_line) ...@@ -636,16 +638,17 @@ CommandInterpreter::execute_impl(const char *_line)
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); m_error = executeConnect(allAfterFirstToken);
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 ||
...@@ -655,11 +658,13 @@ CommandInterpreter::execute_impl(const char *_line) ...@@ -655,11 +658,13 @@ CommandInterpreter::execute_impl(const char *_line)
DBUG_RETURN(false); DBUG_RETURN(false);
} }
if (!connect()) if (!connect()){
m_error = -1;
DBUG_RETURN(true); DBUG_RETURN(true);
}
if (strcasecmp(firstToken, "SHOW") == 0) { if (strcasecmp(firstToken, "SHOW") == 0) {
executeShow(allAfterFirstToken); m_error = executeShow(allAfterFirstToken);
DBUG_RETURN(true); DBUG_RETURN(true);
} }
else if (strcasecmp(firstToken, "SHUTDOWN") == 0) { else if (strcasecmp(firstToken, "SHUTDOWN") == 0) {
...@@ -679,17 +684,17 @@ CommandInterpreter::execute_impl(const char *_line) ...@@ -679,17 +684,17 @@ CommandInterpreter::execute_impl(const char *_line)
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);
} }
#ifdef HAVE_GLOBAL_REPLICATION #ifdef HAVE_GLOBAL_REPLICATION
else if(strcasecmp(firstToken, "REPLICATION") == 0 || else if(strcasecmp(firstToken, "REPLICATION") == 0 ||
strcasecmp(firstToken, "REP") == 0) { strcasecmp(firstToken, "REP") == 0) {
executeRep(allAfterFirstToken); m_error = executeRep(allAfterFirstToken);
DBUG_RETURN(true); DBUG_RETURN(true);
} }
#endif // HAVE_GLOBAL_REPLICATION #endif // HAVE_GLOBAL_REPLICATION
...@@ -697,18 +702,18 @@ CommandInterpreter::execute_impl(const char *_line) ...@@ -697,18 +702,18 @@ CommandInterpreter::execute_impl(const char *_line)
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 token should be a digit, node ID * First token should be a digit, node ID
...@@ -717,15 +722,17 @@ CommandInterpreter::execute_impl(const char *_line) ...@@ -717,15 +722,17 @@ CommandInterpreter::execute_impl(const char *_line)
if (! convert(firstToken, nodeId)) { if (! convert(firstToken, nodeId)) {
invalid_command(_line); invalid_command(_line);
m_error = -1;
DBUG_RETURN(true); DBUG_RETURN(true);
} }
if (nodeId <= 0) { if (nodeId <= 0) {
ndbout << "Invalid node ID: " << firstToken << "." << endl; ndbout << "Invalid node ID: " << firstToken << "." << endl;
m_error = -1;
DBUG_RETURN(true); DBUG_RETURN(true);
} }
analyseAfterFirstToken(nodeId, allAfterFirstToken); m_error = analyseAfterFirstToken(nodeId, allAfterFirstToken);
} }
DBUG_RETURN(true); DBUG_RETURN(true);
...@@ -759,14 +766,15 @@ static const CommandInterpreter::CommandFunctionPair commands[] = { ...@@ -759,14 +766,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, " ");
...@@ -785,15 +793,16 @@ CommandInterpreter::analyseAfterFirstToken(int processId, ...@@ -785,15 +793,16 @@ 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;
} }
/** /**
...@@ -834,18 +843,20 @@ get_next_nodeid(struct ndb_mgm_cluster_state *cl, ...@@ -834,18 +843,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 {
...@@ -853,12 +864,13 @@ CommandInterpreter::executeForAll(const char * cmd, ExecuteFunction fun, ...@@ -853,12 +864,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;
} }
//***************************************************************************** //*****************************************************************************
...@@ -928,7 +940,7 @@ CommandInterpreter::parseBlockSpecification(const char* allAfterLog, ...@@ -928,7 +940,7 @@ CommandInterpreter::parseBlockSpecification(const char* allAfterLog,
/***************************************************************************** /*****************************************************************************
* HELP * HELP
*****************************************************************************/ *****************************************************************************/
void int
CommandInterpreter::executeHelp(char* parameters) CommandInterpreter::executeHelp(char* parameters)
{ {
if (emptyString(parameters)) { if (emptyString(parameters)) {
...@@ -966,7 +978,9 @@ CommandInterpreter::executeHelp(char* parameters) ...@@ -966,7 +978,9 @@ CommandInterpreter::executeHelp(char* parameters)
#endif #endif
} else { } else {
invalid_command(parameters); invalid_command(parameters);
return -1;
} }
return 0;
} }
...@@ -1110,7 +1124,7 @@ print_nodes(ndb_mgm_cluster_state *state, ndb_mgm_configuration_iterator *it, ...@@ -1110,7 +1124,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;
...@@ -1129,7 +1143,7 @@ CommandInterpreter::executePurge(char* parameters) ...@@ -1129,7 +1143,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;
...@@ -1137,7 +1151,7 @@ CommandInterpreter::executePurge(char* parameters) ...@@ -1137,7 +1151,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);
...@@ -1147,9 +1161,10 @@ CommandInterpreter::executePurge(char* parameters) ...@@ -1147,9 +1161,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;
...@@ -1158,7 +1173,7 @@ CommandInterpreter::executeShow(char* parameters) ...@@ -1158,7 +1173,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);
...@@ -1166,7 +1181,7 @@ CommandInterpreter::executeShow(char* parameters) ...@@ -1166,7 +1181,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;
...@@ -1174,7 +1189,7 @@ CommandInterpreter::executeShow(char* parameters) ...@@ -1174,7 +1189,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");
return; return -1;
} }
NdbAutoPtr<ndb_mgm_configuration_iterator> ptr(it); NdbAutoPtr<ndb_mgm_configuration_iterator> ptr(it);
...@@ -1208,7 +1223,7 @@ CommandInterpreter::executeShow(char* parameters) ...@@ -1208,7 +1223,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;
case NDB_MGM_NODE_TYPE_REP: case NDB_MGM_NODE_TYPE_REP:
abort(); abort();
} }
...@@ -1220,7 +1235,7 @@ CommandInterpreter::executeShow(char* parameters) ...@@ -1220,7 +1235,7 @@ CommandInterpreter::executeShow(char* parameters)
print_nodes(state, it, "ndb_mgmd", mgm_nodes, NDB_MGM_NODE_TYPE_MGM, 0); print_nodes(state, it, "ndb_mgmd", mgm_nodes, NDB_MGM_NODE_TYPE_MGM, 0);
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;
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;
...@@ -1237,22 +1252,28 @@ CommandInterpreter::executeShow(char* parameters) ...@@ -1237,22 +1252,28 @@ 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) CommandInterpreter::executeConnect(char* parameters)
{ {
int retval;
disconnect(); disconnect();
if (!emptyString(parameters)) { if (!emptyString(parameters)) {
if (ndb_mgm_set_connectstring(m_mgmsrv, if (retval = ndb_mgm_set_connectstring(m_mgmsrv,
BaseString(parameters).trim().c_str())) BaseString(parameters).trim().c_str()))
{ {
printError(); printError();
return; return retval;
} }
} }
connect(); if ( connect() == false ){
return -1;
}
return 0;
} }
//***************************************************************************** //*****************************************************************************
...@@ -1265,6 +1286,7 @@ CommandInterpreter::executeClusterLog(char* parameters) ...@@ -1265,6 +1286,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;
} }
...@@ -1280,6 +1302,7 @@ CommandInterpreter::executeClusterLog(char* parameters) ...@@ -1280,6 +1302,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;
} }
...@@ -1291,6 +1314,7 @@ CommandInterpreter::executeClusterLog(char* parameters) ...@@ -1291,6 +1314,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
...@@ -1309,6 +1333,7 @@ CommandInterpreter::executeClusterLog(char* parameters) ...@@ -1309,6 +1333,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;
} }
...@@ -1327,6 +1352,7 @@ CommandInterpreter::executeClusterLog(char* parameters) ...@@ -1327,6 +1352,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;
} }
...@@ -1339,9 +1365,11 @@ CommandInterpreter::executeClusterLog(char* parameters) ...@@ -1339,9 +1365,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;
} }
...@@ -1368,6 +1396,7 @@ CommandInterpreter::executeClusterLog(char* parameters) ...@@ -1368,6 +1396,7 @@ CommandInterpreter::executeClusterLog(char* parameters)
} }
if (severity == NDB_MGM_ILLEGAL_CLUSTERLOG_LEVEL) { if (severity == NDB_MGM_ILLEGAL_CLUSTERLOG_LEVEL) {
ndbout << "Invalid severity level: " << item << endl; ndbout << "Invalid severity level: " << item << endl;
m_error = -1;
DBUG_VOID_RETURN; DBUG_VOID_RETURN;
} }
...@@ -1376,23 +1405,26 @@ CommandInterpreter::executeClusterLog(char* parameters) ...@@ -1376,23 +1405,26 @@ 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;
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 *, bool all) CommandInterpreter::executeStop(int processId, const char *, bool all)
{ {
int result = 0; int result = 0;
int retval = 0;
if(all) { if(all) {
result = ndb_mgm_stop(m_mgmsrv, 0, 0); result = ndb_mgm_stop(m_mgmsrv, 0, 0);
} else { } else {
...@@ -1401,6 +1433,7 @@ CommandInterpreter::executeStop(int processId, const char *, bool all) ...@@ -1401,6 +1433,7 @@ CommandInterpreter::executeStop(int processId, const char *, bool all)
if (result < 0) { if (result < 0) {
ndbout << "Shutdown failed." << endl; ndbout << "Shutdown failed." << endl;
printError(); printError();
retval = -1;
} else } else
{ {
if(all) if(all)
...@@ -1408,9 +1441,10 @@ CommandInterpreter::executeStop(int processId, const char *, bool all) ...@@ -1408,9 +1441,10 @@ CommandInterpreter::executeStop(int processId, const char *, bool all)
else else
ndbout << "Node " << processId << " has shutdown." << endl; ndbout << "Node " << processId << " has shutdown." << endl;
} }
return retval;
} }
void int
CommandInterpreter::executeEnterSingleUser(char* parameters) CommandInterpreter::executeEnterSingleUser(char* parameters)
{ {
strtok(parameters, " "); strtok(parameters, " ");
...@@ -1422,37 +1456,42 @@ CommandInterpreter::executeEnterSingleUser(char* parameters) ...@@ -1422,37 +1456,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 {
...@@ -1462,6 +1501,7 @@ CommandInterpreter::executeStart(int processId, const char* parameters, ...@@ -1462,6 +1501,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)
...@@ -1469,9 +1509,10 @@ CommandInterpreter::executeStart(int processId, const char* parameters, ...@@ -1469,9 +1509,10 @@ 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)
{ {
...@@ -1479,6 +1520,7 @@ CommandInterpreter::executeRestart(int processId, const char* parameters, ...@@ -1479,6 +1520,7 @@ CommandInterpreter::executeRestart(int processId, const char* parameters,
int nostart = 0; int nostart = 0;
int initialstart = 0; int initialstart = 0;
int abort = 0; int abort = 0;
int retval = 0;
if(parameters != 0 && strlen(parameters) != 0){ if(parameters != 0 && strlen(parameters) != 0){
char * tmpString = my_strdup(parameters,MYF(MY_WME)); char * tmpString = my_strdup(parameters,MYF(MY_WME));
...@@ -1507,6 +1549,7 @@ CommandInterpreter::executeRestart(int processId, const char* parameters, ...@@ -1507,6 +1549,7 @@ CommandInterpreter::executeRestart(int processId, const char* parameters,
if (result <= 0) { if (result <= 0) {
ndbout.println("Restart failed.", result); ndbout.println("Restart failed.", result);
printError(); printError();
retval = -1;
} else } else
{ {
if(all) if(all)
...@@ -1514,15 +1557,16 @@ CommandInterpreter::executeRestart(int processId, const char* parameters, ...@@ -1514,15 +1557,16 @@ CommandInterpreter::executeRestart(int processId, const char* parameters,
else else
ndbout_c("Node %d is being restarted.", processId); ndbout_c("Node %d is being restarted.", processId);
} }
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;
...@@ -1539,7 +1583,7 @@ CommandInterpreter::executeDumpState(int processId, const char* parameters, ...@@ -1539,7 +1583,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);
...@@ -1551,16 +1595,16 @@ CommandInterpreter::executeDumpState(int processId, const char* parameters, ...@@ -1551,16 +1595,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;
...@@ -1572,7 +1616,7 @@ CommandInterpreter::executeStatus(int processId, ...@@ -1572,7 +1616,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);
...@@ -1581,7 +1625,7 @@ CommandInterpreter::executeStatus(int processId, ...@@ -1581,7 +1625,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;
...@@ -1605,27 +1649,29 @@ CommandInterpreter::executeStatus(int processId, ...@@ -1605,27 +1649,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();
...@@ -1635,14 +1681,14 @@ CommandInterpreter::executeLogLevel(int processId, const char* parameters, ...@@ -1635,14 +1681,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;
...@@ -1658,20 +1704,22 @@ CommandInterpreter::executeLogLevel(int processId, const char* parameters, ...@@ -1658,20 +1704,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
...@@ -1682,29 +1730,30 @@ void CommandInterpreter::executeError(int processId, ...@@ -1682,29 +1730,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;
...@@ -1728,82 +1777,91 @@ CommandInterpreter::executeLog(int processId, ...@@ -1728,82 +1777,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
...@@ -1867,17 +1925,18 @@ CommandInterpreter::executeSet(int /*processId*/, ...@@ -1867,17 +1925,18 @@ CommandInterpreter::executeSet(int /*processId*/,
abort(); abort();
} }
} }
#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
...@@ -1893,19 +1952,21 @@ void CommandInterpreter::executeGetStat(int /*processId*/, ...@@ -1893,19 +1952,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;
...@@ -1952,10 +2013,12 @@ CommandInterpreter::executeEventReporting(int processId, ...@@ -1952,10 +2013,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;
} }
/***************************************************************************** /*****************************************************************************
...@@ -2056,7 +2119,7 @@ CommandInterpreter::executeStartBackup(char* parameters) ...@@ -2056,7 +2119,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;
...@@ -2075,14 +2138,15 @@ CommandInterpreter::executeAbortBackup(char* parameters) ...@@ -2075,14 +2138,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;
} }
#ifdef HAVE_GLOBAL_REPLICATION #ifdef HAVE_GLOBAL_REPLICATION
...@@ -2113,12 +2177,12 @@ CommandInterpreter::executeAbortBackup(char* parameters) ...@@ -2113,12 +2177,12 @@ CommandInterpreter::executeAbortBackup(char* parameters)
*****************************************************************************/ *****************************************************************************/
void int
CommandInterpreter::executeRep(char* parameters) CommandInterpreter::executeRep(char* parameters)
{ {
if (emptyString(parameters)) { if (emptyString(parameters)) {
ndbout << helpTextRep; ndbout << helpTextRep;
return; return 0;
} }
char * line = my_strdup(parameters,MYF(MY_WME)); char * line = my_strdup(parameters,MYF(MY_WME));
...@@ -2138,7 +2202,7 @@ CommandInterpreter::executeRep(char* parameters) ...@@ -2138,7 +2202,7 @@ CommandInterpreter::executeRep(char* parameters)
if(host == NULL) if(host == NULL)
{ {
ndbout_c("host:port must be specified."); ndbout_c("host:port must be specified.");
return; return -1;
} }
if(rep_connected) { if(rep_connected) {
...@@ -2150,14 +2214,17 @@ CommandInterpreter::executeRep(char* parameters) ...@@ -2150,14 +2214,17 @@ CommandInterpreter::executeRep(char* parameters)
if(m_repserver == NULL) if(m_repserver == NULL)
m_repserver = ndb_rep_create_handle(); m_repserver = ndb_rep_create_handle();
if(ndb_rep_connect(m_repserver, host) < 0) if(ndb_rep_connect(m_repserver, host) < 0){
ndbout_c("Failed to connect to %s", host); ndbout_c("Failed to connect to %s", host);
return -1;
}
else else
rep_connected=true; rep_connected=true;
return; return 0;
if(!rep_connected) { if(!rep_connected) {
ndbout_c("Not connected to REP server"); ndbout_c("Not connected to REP server");
return -1;
} }
} }
...@@ -2191,17 +2258,18 @@ CommandInterpreter::executeRep(char* parameters) ...@@ -2191,17 +2258,18 @@ CommandInterpreter::executeRep(char* parameters)
req = GrepReq::START_DELETE; req = GrepReq::START_DELETE;
} else { } else {
ndbout_c("Illegal argument to command 'REPLICATION START'"); ndbout_c("Illegal argument to command 'REPLICATION START'");
return; return -1;
} }
int result = ndb_rep_command(m_repserver, req, &repId, &reply); int result = ndb_rep_command(m_repserver, req, &repId, &reply);
if (result != 0) { if (result != 0) {
ndbout << "Start of Global Replication failed" << endl; ndbout << "Start of Global Replication failed" << endl;
return -1;
} else { } else {
ndbout << "Start of Global Replication ordered" << endl; ndbout << "Start of Global Replication ordered" << endl;
} }
return; return 0;
} }
/******** /********
...@@ -2221,7 +2289,7 @@ CommandInterpreter::executeRep(char* parameters) ...@@ -2221,7 +2289,7 @@ CommandInterpreter::executeRep(char* parameters)
char *strEpoch = strtok(NULL, "\0"); char *strEpoch = strtok(NULL, "\0");
if(strEpoch == NULL) { if(strEpoch == NULL) {
ndbout_c("Epoch expected!"); ndbout_c("Epoch expected!");
return; return -1;
} }
req = GrepReq::STOP; req = GrepReq::STOP;
epoch=atoi(strEpoch); epoch=atoi(strEpoch);
...@@ -2245,16 +2313,17 @@ CommandInterpreter::executeRep(char* parameters) ...@@ -2245,16 +2313,17 @@ CommandInterpreter::executeRep(char* parameters)
req = GrepReq::STOP_DELETE; req = GrepReq::STOP_DELETE;
} else { } else {
ndbout_c("Illegal argument to command 'REPLICATION STOP'"); ndbout_c("Illegal argument to command 'REPLICATION STOP'");
return; return -1;
} }
int result = ndb_rep_command(m_repserver, req, &repId, &reply, epoch); int result = ndb_rep_command(m_repserver, req, &repId, &reply, epoch);
if (result != 0) { if (result != 0) {
ndbout << "Stop command failed" << endl; ndbout << "Stop command failed" << endl;
return -1;
} else { } else {
ndbout << "Stop ordered" << endl; ndbout << "Stop ordered" << endl;
} }
return; return 0;
} }
/********* /*********
...@@ -2267,6 +2336,7 @@ CommandInterpreter::executeRep(char* parameters) ...@@ -2267,6 +2336,7 @@ CommandInterpreter::executeRep(char* parameters)
if (result != 0) { if (result != 0) {
ndbout << "Status request of Global Replication failed" << endl; ndbout << "Status request of Global Replication failed" << endl;
return -1;
} else { } else {
ndbout << "Status request of Global Replication ordered" << endl; ndbout << "Status request of Global Replication ordered" << endl;
ndbout << "See printout at one of the DB nodes" << endl; ndbout << "See printout at one of the DB nodes" << endl;
...@@ -2274,7 +2344,7 @@ CommandInterpreter::executeRep(char* parameters) ...@@ -2274,7 +2344,7 @@ CommandInterpreter::executeRep(char* parameters)
ndbout << " SubscriptionId " << repstate.subid ndbout << " SubscriptionId " << repstate.subid
<< " SubscriptionKey " << repstate.subkey << endl; << " SubscriptionKey " << repstate.subkey << endl;
} }
return; return 0;
} }
/********* /*********
...@@ -2293,6 +2363,7 @@ CommandInterpreter::executeRep(char* parameters) ...@@ -2293,6 +2363,7 @@ CommandInterpreter::executeRep(char* parameters)
if (result != 0) { if (result != 0) {
ndbout << "Query repserver failed" << endl; ndbout << "Query repserver failed" << endl;
return -1;
} else { } else {
ndbout << "Query repserver sucessful" << endl; ndbout << "Query repserver sucessful" << endl;
ndbout_c("repstate : QueryCounter %d, f=%d l=%d" ndbout_c("repstate : QueryCounter %d, f=%d l=%d"
...@@ -2301,8 +2372,9 @@ CommandInterpreter::executeRep(char* parameters) ...@@ -2301,8 +2372,9 @@ CommandInterpreter::executeRep(char* parameters)
repstate.first[0], repstate.last[0], repstate.first[0], repstate.last[0],
repstate.no_of_nodegroups ); repstate.no_of_nodegroups );
} }
return; return 0;
} }
return 0;
} }
#endif // HAVE_GLOBAL_REPLICATION #endif // HAVE_GLOBAL_REPLICATION
......
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