From: Date: September 7 2006 2:52pm Subject: bk commit into 4.1 tree (gni:1.2534) BUG#21530 List-Archive: http://lists.mysql.com/commits/11587 X-Bug: 21530 Message-Id: <200609071252.k87CqZxd011224@dev3-127> Below is the list of changes that have just been committed into a local 4.1 repository of root. When root does a push these changes will be propagated to the main repository and, within 24 hours after the push, to the public repository. For information on how to access the public repository see http://dev.mysql.com/doc/mysql/en/installing-source-tree.html ChangeSet@stripped, 2006-09-07 20:50:33+08:00, gni@dev3-127.(none) +1 -0 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 excution whether or not success for many methods. ndb/src/mgmclient/CommandInterpreter.cpp@stripped, 2006-09-07 20:50:31+08:00, gni@dev3-127.(none) +194 -122 Many methods add the return value that indicates whether the execution of operation succeeds. This can make ndb_mgm management client set the exit status on errors. # This is a BitKeeper patch. What follows are the unified diffs for the # set of deltas contained in the patch. The rest of the patch, the part # that BitKeeper cares about, is below these diffs. # User: gni # Host: dev3-127.(none) # Root: /mnt/mysql/home/ngb/mysql-4.1/mysql-4.1-bug21530 --- 1.51/ndb/src/mgmclient/CommandInterpreter.cpp 2006-09-07 20:51:36 +08:00 +++ 1.52/ndb/src/mgmclient/CommandInterpreter.cpp 2006-09-07 20:51:36 +08:00 @@ -67,8 +67,9 @@ * command will be sent to all DB processes. * @param allAfterFirstToken: What the client gave after the * 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, @@ -93,38 +94,38 @@ * this case "22". Each function is responsible to check the parameters * argument. */ - void executeHelp(char* parameters); - void executeShow(char* parameters); - void executeConnect(char* parameters); - void executePurge(char* parameters); + int executeHelp(char* parameters); + int executeShow(char* parameters); + int executeConnect(char* parameters); + int executePurge(char* parameters); int executeShutdown(char* parameters); void executeRun(char* parameters); void executeInfo(char* parameters); void executeClusterLog(char* parameters); public: - void executeStop(int processId, const char* parameters, bool all); - void executeEnterSingleUser(char* parameters); - void executeExitSingleUser(char* parameters); - void executeStart(int processId, const char* parameters, bool all); - void executeRestart(int processId, const char* parameters, bool all); - 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); + int executeStop(int processId, const char* parameters, bool all); + 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); - void executeRep(char* parameters); + int executeRep(char* parameters); void executeCpc(char * parameters); @@ -136,7 +137,7 @@ * A execute function definition */ public: - typedef void (CommandInterpreter::* ExecuteFunction)(int processId, + typedef int (CommandInterpreter::* ExecuteFunction)(int processId, const char * param, bool all); @@ -148,7 +149,7 @@ /** * */ - void executeForAll(const char * cmd, + int executeForAll(const char * cmd, ExecuteFunction fun, const char * param); @@ -606,6 +607,7 @@ char * line; if(_line == NULL) { + m_error = -1; DBUG_RETURN(false); } line = my_strdup(_line,MYF(MY_WME)); @@ -636,16 +638,17 @@ if (strcasecmp(firstToken, "HELP") == 0 || strcasecmp(firstToken, "?") == 0) { - executeHelp(allAfterFirstToken); + m_error = executeHelp(allAfterFirstToken); DBUG_RETURN(true); } else if (strcasecmp(firstToken, "CONNECT") == 0) { - executeConnect(allAfterFirstToken); + m_error = executeConnect(allAfterFirstToken); DBUG_RETURN(true); } else if (strcasecmp(firstToken, "SLEEP") == 0) { if (allAfterFirstToken) - sleep(atoi(allAfterFirstToken)); + if (sleep(atoi(allAfterFirstToken)) != 0 ) + m_error = -1; DBUG_RETURN(true); } else if((strcasecmp(firstToken, "QUIT") == 0 || @@ -655,11 +658,13 @@ DBUG_RETURN(false); } - if (!connect()) + if (!connect()){ + m_error = -1; DBUG_RETURN(true); + } if (strcasecmp(firstToken, "SHOW") == 0) { - executeShow(allAfterFirstToken); + m_error = executeShow(allAfterFirstToken); DBUG_RETURN(true); } else if (strcasecmp(firstToken, "SHUTDOWN") == 0) { @@ -679,17 +684,17 @@ else if(strcasecmp(firstToken, "ABORT") == 0 && allAfterFirstToken != NULL && strncasecmp(allAfterFirstToken, "BACKUP", sizeof("BACKUP") - 1) == 0){ - executeAbortBackup(allAfterFirstToken); + m_error = executeAbortBackup(allAfterFirstToken); DBUG_RETURN(true); } else if (strcasecmp(firstToken, "PURGE") == 0) { - executePurge(allAfterFirstToken); + m_error = executePurge(allAfterFirstToken); DBUG_RETURN(true); } #ifdef HAVE_GLOBAL_REPLICATION else if(strcasecmp(firstToken, "REPLICATION") == 0 || strcasecmp(firstToken, "REP") == 0) { - executeRep(allAfterFirstToken); + m_error = executeRep(allAfterFirstToken); DBUG_RETURN(true); } #endif // HAVE_GLOBAL_REPLICATION @@ -697,18 +702,18 @@ allAfterFirstToken != NULL && strncasecmp(allAfterFirstToken, "SINGLE USER MODE ", sizeof("SINGLE USER MODE") - 1) == 0){ - executeEnterSingleUser(allAfterFirstToken); + m_error = executeEnterSingleUser(allAfterFirstToken); DBUG_RETURN(true); } else if(strcasecmp(firstToken, "EXIT") == 0 && allAfterFirstToken != NULL && strncasecmp(allAfterFirstToken, "SINGLE USER MODE ", sizeof("SINGLE USER MODE") - 1) == 0){ - executeExitSingleUser(allAfterFirstToken); + m_error = executeExitSingleUser(allAfterFirstToken); DBUG_RETURN(true); } else if (strcasecmp(firstToken, "ALL") == 0) { - analyseAfterFirstToken(-1, allAfterFirstToken); + m_error = analyseAfterFirstToken(-1, allAfterFirstToken); } else { /** * First token should be a digit, node ID @@ -717,15 +722,17 @@ if (! convert(firstToken, nodeId)) { invalid_command(_line); + m_error = -1; DBUG_RETURN(true); } if (nodeId <= 0) { ndbout << "Invalid node ID: " << firstToken << "." << endl; + m_error = -1; DBUG_RETURN(true); } - analyseAfterFirstToken(nodeId, allAfterFirstToken); + m_error = analyseAfterFirstToken(nodeId, allAfterFirstToken); } DBUG_RETURN(true); @@ -759,14 +766,15 @@ //***************************************************************************** //***************************************************************************** -void +int CommandInterpreter::analyseAfterFirstToken(int processId, char* allAfterFirstToken) { + int retval = 0; if (emptyString(allAfterFirstToken)) { ndbout << "Expected a command after " << ((processId == -1) ? "ALL." : "node ID.") << endl; - return; + return -1; } char* secondToken = strtok(allAfterFirstToken, " "); @@ -785,15 +793,16 @@ if(fun == 0){ invalid_command(secondToken); - return; + return -1; } if(processId == -1){ - executeForAll(command, fun, allAfterSecondToken); + retval = executeForAll(command, fun, allAfterSecondToken); } else { - (this->*fun)(processId, allAfterSecondToken, false); + retval = (this->*fun)(processId, allAfterSecondToken, false); } ndbout << endl; + return retval; } /** @@ -834,18 +843,20 @@ return 0; } -void +int CommandInterpreter::executeForAll(const char * cmd, ExecuteFunction fun, const char * allAfterSecondToken) { int nodeId = 0; + int retval = 0; + if(strcasecmp(cmd, "STOP") == 0) { ndbout_c("Executing STOP on all nodes."); - (this->*fun)(nodeId, allAfterSecondToken, true); + retval = (this->*fun)(nodeId, allAfterSecondToken, true); } else if(strcasecmp(cmd, "RESTART") == 0) { ndbout_c("Executing RESTART on all nodes."); 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("Use ALL STATUS to see the system start-up phases."); } else { @@ -853,12 +864,13 @@ if(cl == 0){ ndbout_c("Unable get status from management server"); printError(); - return; + return -1; } NdbAutoPtr ap1((char*)cl); 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 @@ /***************************************************************************** * HELP *****************************************************************************/ -void +int CommandInterpreter::executeHelp(char* parameters) { if (emptyString(parameters)) { @@ -966,7 +978,9 @@ #endif } else { invalid_command(parameters); + return -1; } + return 0; } @@ -1110,7 +1124,7 @@ ndbout << endl; } -void +int CommandInterpreter::executePurge(char* parameters) { int command_ok= 0; @@ -1129,7 +1143,7 @@ if (!command_ok) { ndbout_c("Unexpected command, expected: PURGE STALE SESSIONS"); - return; + return -1; } int i; @@ -1137,7 +1151,7 @@ if (ndb_mgm_purge_stale_sessions(m_mgmsrv, &str)) { ndbout_c("Command failed"); - return; + return -1; } if (str) { ndbout_c("Purged sessions with node id's: %s", str); @@ -1147,9 +1161,10 @@ { ndbout_c("No sessions purged"); } + return 0; } -void +int CommandInterpreter::executeShow(char* parameters) { int i; @@ -1158,7 +1173,7 @@ if(state == NULL) { ndbout_c("Could not get status"); printError(); - return; + return -1; } NdbAutoPtr ap1((char*)state); @@ -1166,7 +1181,7 @@ if(conf == 0){ ndbout_c("Could not get configuration"); printError(); - return; + return -1; } ndb_mgm_configuration_iterator * it; @@ -1174,7 +1189,7 @@ if(it == 0){ ndbout_c("Unable to create config iterator"); - return; + return -1; } NdbAutoPtr ptr(it); @@ -1208,7 +1223,7 @@ break; case NDB_MGM_NODE_TYPE_UNKNOWN: ndbout << "Error: Unknown Node Type" << endl; - return; + return -1; case NDB_MGM_NODE_TYPE_REP: abort(); } @@ -1220,7 +1235,7 @@ 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); // ndbout << helpTextShow; - return; + return 0; } else if (strcasecmp(parameters, "PROPERTIES") == 0 || strcasecmp(parameters, "PROP") == 0) { ndbout << "SHOW PROPERTIES is not yet implemented." << endl; @@ -1237,22 +1252,28 @@ // << endl; /* XXX */ } else { ndbout << "Invalid argument." << endl; + return -1; } + return 0; } -void +int CommandInterpreter::executeConnect(char* parameters) { + int retval; disconnect(); if (!emptyString(parameters)) { - if (ndb_mgm_set_connectstring(m_mgmsrv, + if (retval = ndb_mgm_set_connectstring(m_mgmsrv, BaseString(parameters).trim().c_str())) { printError(); - return; + return retval; } } - connect(); + if ( connect() == false ){ + return -1; + } + return 0; } //***************************************************************************** @@ -1265,6 +1286,7 @@ if (emptyString(parameters)) { ndbout << "Missing argument." << endl; + m_error = -1; DBUG_VOID_RETURN; } @@ -1280,6 +1302,7 @@ if(enabled == NULL) { ndbout << "Couldn't get status" << endl; printError(); + m_error = -1; DBUG_VOID_RETURN; } @@ -1291,6 +1314,7 @@ if(enabled[0] == 0) { ndbout << "Cluster logging is disabled." << endl; + m_error = 0; DBUG_VOID_RETURN; } #if 0 @@ -1309,6 +1333,7 @@ ndbout << BaseString(str).ndb_toupper() << " "; } ndbout << endl; + m_error = 0; DBUG_VOID_RETURN; } @@ -1327,6 +1352,7 @@ enable= 1; } else { ndbout << "Invalid argument." << endl; + m_error = -1; DBUG_VOID_RETURN; } @@ -1339,9 +1365,11 @@ { ndbout << "Couldn't set filter" << endl; printError(); + m_error = -1; DBUG_VOID_RETURN; } ndbout << "Cluster logging is " << (res_enable ? "enabled.":"disabled") << endl; + m_error = 0; DBUG_VOID_RETURN; } @@ -1368,6 +1396,7 @@ } if (severity == NDB_MGM_ILLEGAL_CLUSTERLOG_LEVEL) { ndbout << "Invalid severity level: " << item << endl; + m_error = -1; DBUG_VOID_RETURN; } @@ -1376,23 +1405,26 @@ { ndbout << "Couldn't set filter" << endl; printError(); + m_error = -1; DBUG_VOID_RETURN; } ndbout << BaseString(item).ndb_toupper().c_str() << " " << (res_enable ? "enabled":"disabled") << endl; item = strtok_r(NULL, " ", &tmpPtr); } while(item != NULL); - + + m_error = 0; DBUG_VOID_RETURN; } //***************************************************************************** //***************************************************************************** -void +int CommandInterpreter::executeStop(int processId, const char *, bool all) { int result = 0; + int retval = 0; if(all) { result = ndb_mgm_stop(m_mgmsrv, 0, 0); } else { @@ -1401,6 +1433,7 @@ if (result < 0) { ndbout << "Shutdown failed." << endl; printError(); + retval = -1; } else { if(all) @@ -1408,9 +1441,10 @@ else ndbout << "Node " << processId << " has shutdown." << endl; } + return retval; } -void +int CommandInterpreter::executeEnterSingleUser(char* parameters) { strtok(parameters, " "); @@ -1422,37 +1456,42 @@ if(id == 0 || sscanf(id, "%d", &nodeId) != 1){ ndbout_c("Invalid arguments: expected "); 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); if (result != 0) { ndbout_c("Entering single user mode for node %d failed", nodeId); printError(); + return -1; } else { ndbout_c("Single user mode entered"); ndbout_c("Access is granted for API node %d only.", nodeId); } + return 0; } -void +int CommandInterpreter::executeExitSingleUser(char* parameters) { int result = ndb_mgm_exit_single_user(m_mgmsrv, 0); if (result != 0) { ndbout_c("Exiting single user mode failed."); printError(); + return -1; } else { ndbout_c("Exiting single user mode in progress."); 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, bool all) { int result; + int retval = 0; if(all) { result = ndb_mgm_start(m_mgmsrv, 0, 0); } else { @@ -1462,6 +1501,7 @@ if (result <= 0) { ndbout << "Start failed." << endl; printError(); + retval = -1; } else { if(all) @@ -1469,9 +1509,10 @@ else ndbout_c("Database node %d is being started.", processId); } + return retval; } -void +int CommandInterpreter::executeRestart(int processId, const char* parameters, bool all) { @@ -1479,6 +1520,7 @@ int nostart = 0; int initialstart = 0; int abort = 0; + int retval = 0; if(parameters != 0 && strlen(parameters) != 0){ char * tmpString = my_strdup(parameters,MYF(MY_WME)); @@ -1507,6 +1549,7 @@ if (result <= 0) { ndbout.println("Restart failed.", result); printError(); + retval = -1; } else { if(all) @@ -1514,15 +1557,16 @@ else ndbout_c("Node %d is being restarted.", processId); } + return retval; } -void +int CommandInterpreter::executeDumpState(int processId, const char* parameters, bool all) { if(emptyString(parameters)){ ndbout << "Expected argument" << endl; - return; + return -1; } Uint32 no = 0; @@ -1539,7 +1583,7 @@ ndbout << "Illegal value in argument to signal." << endl << "(Value must be between 0 and 0xffffffff.)" << endl; - return; + return -1; } no++; item = strtok_r(NULL, " ", &tmpPtr); @@ -1551,16 +1595,16 @@ } 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, const char* parameters, bool all) { if (! emptyString(parameters)) { ndbout_c("No parameters expected to this command."); - return; + return -1; } ndb_mgm_node_status status; @@ -1572,7 +1616,7 @@ if(cl == NULL) { ndbout_c("Cannot get status of node %d.", processId); printError(); - return; + return -1; } NdbAutoPtr ap1((char*)cl); @@ -1581,7 +1625,7 @@ i++; if(cl->node_states[i].node_id != processId) { ndbout << processId << ": Node not found" << endl; - return; + return -1; } status = cl->node_states[i].node_status; startPhase = cl->node_states[i].start_phase; @@ -1605,27 +1649,29 @@ getBuild(version)); else ndbout << endl; + + return 0; } //***************************************************************************** //***************************************************************************** -void +int CommandInterpreter::executeLogLevel(int processId, const char* parameters, bool all) { (void) all; if (emptyString(parameters)) { ndbout << "Expected argument" << endl; - return; + return -1; } BaseString tmp(parameters); Vector spec; tmp.split(spec, "="); if(spec.size() != 2){ ndbout << "Invalid loglevel specification: " << parameters << endl; - return; + return -1; } spec[0].trim().ndb_toupper(); @@ -1635,14 +1681,14 @@ if(category < NDB_MGM_MIN_EVENT_CATEGORY || category > NDB_MGM_MAX_EVENT_CATEGORY){ ndbout << "Unknown category: \"" << spec[0].c_str() << "\"" << endl; - return; + return -1; } } int level = atoi(spec[1].c_str()); if(level < 0 || level > 15){ ndbout << "Invalid level: " << spec[1].c_str() << endl; - return; + return -1; } ndbout << "Executing LOGLEVEL on node " << processId << flush; @@ -1658,20 +1704,22 @@ if (result < 0) { ndbout_c(" failed."); printError(); + return -1; } else { ndbout_c(" OK!"); } - + return 0; } //***************************************************************************** //***************************************************************************** -void CommandInterpreter::executeError(int processId, +int CommandInterpreter::executeError(int processId, const char* parameters, bool /* all */) { + int retval = 0; if (emptyString(parameters)) { ndbout << "Missing error number." << endl; - return; + return -1; } // Copy parameters since strtok will modify it @@ -1682,29 +1730,30 @@ int errorNo; if (! convert(firstParameter, errorNo)) { ndbout << "Expected an integer." << endl; - return; + return -1; } char* allAfterFirstParameter = strtok(NULL, "\0"); if (! emptyString(allAfterFirstParameter)) { 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, const char* parameters, bool all) { struct ndb_mgm_reply reply; Vector blocks; if (! parseBlockSpecification(parameters, blocks)) { - return; + return -1; } int len=1; Uint32 i; @@ -1728,82 +1777,91 @@ if (result != 0) { ndbout_c("Execute LOG on node %d failed.", processId); printError(); + return -1; } + return 0; } //***************************************************************************** //***************************************************************************** -void +int CommandInterpreter::executeLogIn(int /* processId */, const char* parameters, bool /* all */) { ndbout << "Command LOGIN not implemented." << endl; + return 0; } //***************************************************************************** //***************************************************************************** -void +int CommandInterpreter::executeLogOut(int /*processId*/, const char* parameters, bool /*all*/) { ndbout << "Command LOGOUT not implemented." << endl; + return 0; } //***************************************************************************** //***************************************************************************** -void +int CommandInterpreter::executeLogOff(int /*processId*/, const char* parameters, bool /*all*/) { ndbout << "Command LOGOFF not implemented." << endl; + return 0; } //***************************************************************************** //***************************************************************************** -void +int CommandInterpreter::executeTestOn(int processId, const char* parameters, bool /*all*/) { if (! emptyString(parameters)) { ndbout << "No parameters expected to this command." << endl; - return; + return -1; } struct ndb_mgm_reply reply; int result = ndb_mgm_start_signallog(m_mgmsrv, processId, &reply); if (result != 0) { ndbout_c("Execute TESTON failed."); printError(); + return -1; } + return 0; } //***************************************************************************** //***************************************************************************** -void +int CommandInterpreter::executeTestOff(int processId, const char* parameters, bool /*all*/) { if (! emptyString(parameters)) { ndbout << "No parameters expected to this command." << endl; - return; + return -1; } struct ndb_mgm_reply reply; int result = ndb_mgm_stop_signallog(m_mgmsrv, processId, &reply); if (result != 0) { ndbout_c("Execute TESTOFF failed."); printError(); + return -1; } + return 0; } //***************************************************************************** //***************************************************************************** -void +int CommandInterpreter::executeSet(int /*processId*/, const char* parameters, bool /*all*/) { if (emptyString(parameters)) { ndbout << "Missing parameter name." << endl; - return; + return -1; } #if 0 // Copy parameters since strtok will modify it @@ -1867,17 +1925,18 @@ abort(); } } -#endif +#endif + return 0; } //***************************************************************************** //***************************************************************************** -void CommandInterpreter::executeGetStat(int /*processId*/, +int CommandInterpreter::executeGetStat(int /*processId*/, const char* parameters, bool /*all*/) { if (! emptyString(parameters)) { ndbout << "No parameters expected to this command." << endl; - return; + return -1; } #if 0 @@ -1893,19 +1952,21 @@ ndbout << "Number of GETSTAT commands: " << statistics._test1 << endl; */ + return 0; } //***************************************************************************** //***************************************************************************** -void +int CommandInterpreter::executeEventReporting(int processId, const char* parameters, bool all) { + int retval = 0; if (emptyString(parameters)) { ndbout << "Expected argument" << endl; - return; + return -1; } BaseString tmp(parameters); Vector specs; @@ -1952,10 +2013,12 @@ if (result != 0) { ndbout_c(" failed."); printError(); + retval = -1; } else { ndbout_c(" OK!"); } } + return retval; } /***************************************************************************** @@ -2056,7 +2119,7 @@ return 0; } -void +int CommandInterpreter::executeAbortBackup(char* parameters) { int bid = -1; @@ -2075,14 +2138,15 @@ if (result != 0) { ndbout << "Abort of backup " << bid << " failed" << endl; printError(); + return -1; } else { ndbout << "Abort of backup " << bid << " ordered" << endl; } } - return; + return 0; executeAbortBackupError1: ndbout << "Invalid arguments: expected " << endl; - return; + return -1; } #ifdef HAVE_GLOBAL_REPLICATION @@ -2113,12 +2177,12 @@ *****************************************************************************/ -void +int CommandInterpreter::executeRep(char* parameters) { if (emptyString(parameters)) { ndbout << helpTextRep; - return; + return 0; } char * line = my_strdup(parameters,MYF(MY_WME)); @@ -2138,7 +2202,7 @@ if(host == NULL) { ndbout_c("host:port must be specified."); - return; + return -1; } if(rep_connected) { @@ -2150,14 +2214,17 @@ if(m_repserver == NULL) m_repserver = ndb_rep_create_handle(); - if(ndb_rep_connect(m_repserver, host) < 0) - ndbout_c("Failed to connect to %s", host); + if(ndb_rep_connect(m_repserver, host) < 0){ + ndbout_c("Failed to connect to %s", host); + return -1; + } else rep_connected=true; - return; + return 0; if(!rep_connected) { ndbout_c("Not connected to REP server"); + return -1; } } @@ -2191,17 +2258,18 @@ req = GrepReq::START_DELETE; } else { ndbout_c("Illegal argument to command 'REPLICATION START'"); - return; + return -1; } int result = ndb_rep_command(m_repserver, req, &repId, &reply); if (result != 0) { ndbout << "Start of Global Replication failed" << endl; + return -1; } else { ndbout << "Start of Global Replication ordered" << endl; } - return; + return 0; } /******** @@ -2221,7 +2289,7 @@ char *strEpoch = strtok(NULL, "\0"); if(strEpoch == NULL) { ndbout_c("Epoch expected!"); - return; + return -1; } req = GrepReq::STOP; epoch=atoi(strEpoch); @@ -2245,16 +2313,17 @@ req = GrepReq::STOP_DELETE; } else { ndbout_c("Illegal argument to command 'REPLICATION STOP'"); - return; + return -1; } int result = ndb_rep_command(m_repserver, req, &repId, &reply, epoch); if (result != 0) { ndbout << "Stop command failed" << endl; + return -1; } else { ndbout << "Stop ordered" << endl; } - return; + return 0; } /********* @@ -2267,6 +2336,7 @@ if (result != 0) { ndbout << "Status request of Global Replication failed" << endl; + return -1; } else { ndbout << "Status request of Global Replication ordered" << endl; ndbout << "See printout at one of the DB nodes" << endl; @@ -2274,7 +2344,7 @@ ndbout << " SubscriptionId " << repstate.subid << " SubscriptionKey " << repstate.subkey << endl; } - return; + return 0; } /********* @@ -2293,6 +2363,7 @@ if (result != 0) { ndbout << "Query repserver failed" << endl; + return -1; } else { ndbout << "Query repserver sucessful" << endl; ndbout_c("repstate : QueryCounter %d, f=%d l=%d" @@ -2301,8 +2372,9 @@ repstate.first[0], repstate.last[0], repstate.no_of_nodegroups ); } - return; + return 0; } + return 0; } #endif // HAVE_GLOBAL_REPLICATION