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:
* 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 @@ private:
* 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);
void executeRep(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);
int executeRep(char* parameters);
void executeCpc(char * parameters);
......@@ -136,7 +137,7 @@ public:
* 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 @@ private:
/**
*
*/
void executeForAll(const char * cmd,
int executeForAll(const char * cmd,
ExecuteFunction fun,
const char * param);
......@@ -606,6 +607,7 @@ CommandInterpreter::execute_impl(const char *_line)
char * line;
if(_line == NULL) {
m_error = -1;
DBUG_RETURN(false);
}
line = my_strdup(_line,MYF(MY_WME));
......@@ -636,16 +638,17 @@ CommandInterpreter::execute_impl(const char *_line)
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 @@ CommandInterpreter::execute_impl(const char *_line)
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 @@ CommandInterpreter::execute_impl(const char *_line)
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 @@ CommandInterpreter::execute_impl(const char *_line)
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 @@ CommandInterpreter::execute_impl(const char *_line)
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 @@ static const CommandInterpreter::CommandFunctionPair commands[] = {
//*****************************************************************************
//*****************************************************************************
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 @@ CommandInterpreter::analyseAfterFirstToken(int processId,
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 @@ get_next_nodeid(struct ndb_mgm_cluster_state *cl,
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 @@ CommandInterpreter::executeForAll(const char * cmd, ExecuteFunction fun,
if(cl == 0){
ndbout_c("Unable get status from management server");
printError();
return;
return -1;
}
NdbAutoPtr<char> 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 @@ CommandInterpreter::parseBlockSpecification(const char* allAfterLog,
/*****************************************************************************
* HELP
*****************************************************************************/
void
int
CommandInterpreter::executeHelp(char* parameters)
{
if (emptyString(parameters)) {
......@@ -966,7 +978,9 @@ CommandInterpreter::executeHelp(char* parameters)
#endif
} else {
invalid_command(parameters);
return -1;
}
return 0;
}
......@@ -1110,7 +1124,7 @@ print_nodes(ndb_mgm_cluster_state *state, ndb_mgm_configuration_iterator *it,
ndbout << endl;
}
void
int
CommandInterpreter::executePurge(char* parameters)
{
int command_ok= 0;
......@@ -1129,7 +1143,7 @@ CommandInterpreter::executePurge(char* parameters)
if (!command_ok) {
ndbout_c("Unexpected command, expected: PURGE STALE SESSIONS");
return;
return -1;
}
int i;
......@@ -1137,7 +1151,7 @@ CommandInterpreter::executePurge(char* parameters)
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 @@ CommandInterpreter::executePurge(char* parameters)
{
ndbout_c("No sessions purged");
}
return 0;
}
void
int
CommandInterpreter::executeShow(char* parameters)
{
int i;
......@@ -1158,7 +1173,7 @@ CommandInterpreter::executeShow(char* parameters)
if(state == NULL) {
ndbout_c("Could not get status");
printError();
return;
return -1;
}
NdbAutoPtr<char> ap1((char*)state);
......@@ -1166,7 +1181,7 @@ CommandInterpreter::executeShow(char* parameters)
if(conf == 0){
ndbout_c("Could not get configuration");
printError();
return;
return -1;
}
ndb_mgm_configuration_iterator * it;
......@@ -1174,7 +1189,7 @@ CommandInterpreter::executeShow(char* parameters)
if(it == 0){
ndbout_c("Unable to create config iterator");
return;
return -1;
}
NdbAutoPtr<ndb_mgm_configuration_iterator> ptr(it);
......@@ -1208,7 +1223,7 @@ CommandInterpreter::executeShow(char* parameters)
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 @@ CommandInterpreter::executeShow(char* parameters)
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 @@ CommandInterpreter::executeShow(char* parameters)
// << 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 @@ CommandInterpreter::executeClusterLog(char* parameters)
if (emptyString(parameters))
{
ndbout << "Missing argument." << endl;
m_error = -1;
DBUG_VOID_RETURN;
}
......@@ -1280,6 +1302,7 @@ CommandInterpreter::executeClusterLog(char* parameters)
if(enabled == NULL) {
ndbout << "Couldn't get status" << endl;
printError();
m_error = -1;
DBUG_VOID_RETURN;
}
......@@ -1291,6 +1314,7 @@ CommandInterpreter::executeClusterLog(char* parameters)
if(enabled[0] == 0)
{
ndbout << "Cluster logging is disabled." << endl;
m_error = 0;
DBUG_VOID_RETURN;
}
#if 0
......@@ -1309,6 +1333,7 @@ CommandInterpreter::executeClusterLog(char* parameters)
ndbout << BaseString(str).ndb_toupper() << " ";
}
ndbout << endl;
m_error = 0;
DBUG_VOID_RETURN;
}
......@@ -1327,6 +1352,7 @@ CommandInterpreter::executeClusterLog(char* parameters)
enable= 1;
} else {
ndbout << "Invalid argument." << endl;
m_error = -1;
DBUG_VOID_RETURN;
}
......@@ -1339,9 +1365,11 @@ CommandInterpreter::executeClusterLog(char* parameters)
{
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 @@ CommandInterpreter::executeClusterLog(char* parameters)
}
if (severity == NDB_MGM_ILLEGAL_CLUSTERLOG_LEVEL) {
ndbout << "Invalid severity level: " << item << endl;
m_error = -1;
DBUG_VOID_RETURN;
}
......@@ -1376,23 +1405,26 @@ CommandInterpreter::executeClusterLog(char* parameters)
{
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 @@ CommandInterpreter::executeStop(int processId, const char *, bool all)
if (result < 0) {
ndbout << "Shutdown failed." << endl;
printError();
retval = -1;
} else
{
if(all)
......@@ -1408,9 +1441,10 @@ CommandInterpreter::executeStop(int processId, const char *, bool all)
else
ndbout << "Node " << processId << " has shutdown." << endl;
}
return retval;
}
void
int
CommandInterpreter::executeEnterSingleUser(char* parameters)
{
strtok(parameters, " ");
......@@ -1422,37 +1456,42 @@ CommandInterpreter::executeEnterSingleUser(char* parameters)
if(id == 0 || sscanf(id, "%d", &nodeId) != 1){
ndbout_c("Invalid arguments: expected <NodeId>");
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 @@ CommandInterpreter::executeStart(int processId, const char* parameters,
if (result <= 0) {
ndbout << "Start failed." << endl;
printError();
retval = -1;
} else
{
if(all)
......@@ -1469,9 +1509,10 @@ CommandInterpreter::executeStart(int processId, const char* parameters,
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 @@ CommandInterpreter::executeRestart(int processId, const char* parameters,
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 @@ CommandInterpreter::executeRestart(int processId, const char* parameters,
if (result <= 0) {
ndbout.println("Restart failed.", result);
printError();
retval = -1;
} else
{
if(all)
......@@ -1514,15 +1557,16 @@ CommandInterpreter::executeRestart(int processId, const char* parameters,
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 @@ CommandInterpreter::executeDumpState(int processId, const char* parameters,
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 @@ CommandInterpreter::executeDumpState(int processId, const char* parameters,
}
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 @@ CommandInterpreter::executeStatus(int processId,
if(cl == NULL) {
ndbout_c("Cannot get status of node %d.", processId);
printError();
return;
return -1;
}
NdbAutoPtr<char> ap1((char*)cl);
......@@ -1581,7 +1625,7 @@ CommandInterpreter::executeStatus(int processId,
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 @@ CommandInterpreter::executeStatus(int processId,
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<BaseString> 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 @@ CommandInterpreter::executeLogLevel(int processId, const char* parameters,
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 @@ CommandInterpreter::executeLogLevel(int processId, const char* parameters,
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 @@ void CommandInterpreter::executeError(int processId,
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<const char *> blocks;
if (! parseBlockSpecification(parameters, blocks)) {
return;
return -1;
}
int len=1;
Uint32 i;
......@@ -1728,82 +1777,91 @@ CommandInterpreter::executeLog(int processId,
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 @@ CommandInterpreter::executeSet(int /*processId*/,
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 @@ void CommandInterpreter::executeGetStat(int /*processId*/,
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<BaseString> specs;
......@@ -1952,10 +2013,12 @@ CommandInterpreter::executeEventReporting(int processId,
if (result != 0) {
ndbout_c(" failed.");
printError();
retval = -1;
} else {
ndbout_c(" OK!");
}
}
return retval;
}
/*****************************************************************************
......@@ -2056,7 +2119,7 @@ CommandInterpreter::executeStartBackup(char* parameters)
return 0;
}
void
int
CommandInterpreter::executeAbortBackup(char* parameters)
{
int bid = -1;
......@@ -2075,14 +2138,15 @@ CommandInterpreter::executeAbortBackup(char* parameters)
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 <BackupId>" << endl;
return;
return -1;
}
#ifdef HAVE_GLOBAL_REPLICATION
......@@ -2113,12 +2177,12 @@ CommandInterpreter::executeAbortBackup(char* parameters)
*****************************************************************************/
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 @@ CommandInterpreter::executeRep(char* parameters)
if(host == NULL)
{
ndbout_c("host:port must be specified.");
return;
return -1;
}
if(rep_connected) {
......@@ -2150,14 +2214,17 @@ CommandInterpreter::executeRep(char* parameters)
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 @@ CommandInterpreter::executeRep(char* parameters)
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 @@ CommandInterpreter::executeRep(char* parameters)
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 @@ CommandInterpreter::executeRep(char* parameters)
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 @@ CommandInterpreter::executeRep(char* parameters)
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 @@ CommandInterpreter::executeRep(char* parameters)
ndbout << " SubscriptionId " << repstate.subid
<< " SubscriptionKey " << repstate.subkey << endl;
}
return;
return 0;
}
/*********
......@@ -2293,6 +2363,7 @@ CommandInterpreter::executeRep(char* parameters)
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 @@ CommandInterpreter::executeRep(char* parameters)
repstate.first[0], repstate.last[0],
repstate.no_of_nodegroups );
}
return;
return 0;
}
return 0;
}
#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