Skip to content

M
mariadb
Commit 99395d5d authored by lzhou/root@dev3-138.dev.cn.tlan's avatar lzhou/root@dev3-138.dev.cn.tlan
Browse files
Options

Merge lzhou@bk-internal.mysql.com:/home/bk/mysql-5.0-ndb-bj 

into  dev3-138.dev.cn.tlan:/home/zhl/mysql/mysql-5.0/bug21799
parents 636368ca 5bf03276
Hide whitespace changes
Inline Side-by-side
Showing with 356 additions and 143 deletions
ndb/include/mgmapi/mgmapi.h
View file @ 99395d5d
......@@ -862,6 +862,15 @@ extern "C" {
enum ndb_mgm_event_category category,
int level,
struct ndb_mgm_reply* reply);
/**
* get log category and levels
*
* @param handle NDB management handle.
* @return A vector of twelve elements,
* where each element contains
* loglevel of corresponding category
*/
const unsigned int *ndb_mgm_get_clusterlog_loglevel(NdbMgmHandle handle);
/** @} *********************************************************************/
/**
......@@ -1141,6 +1150,11 @@ extern "C" {
enum ndb_mgm_event_category c,
int l, struct ndb_mgm_reply* r)
{ return ndb_mgm_set_clusterlog_loglevel(h,n,c,l,r); }
inline
const unsigned int *ndb_mgm_get_loglevel_clusterlog(NdbMgmHandle h)
{ return ndb_mgm_get_clusterlog_loglevel(h); }
#endif
#ifdef __cplusplus
......
ndb/include/util/File.hpp
View file @ 99395d5d
......@@ -28,6 +28,14 @@
class File_class
{
public:
/**
* Returns time for last contents modification of a file.
*
* @param aFileName a filename to check.
* @return the time for last contents modificaton of the file.
*/
static time_t mtime(const char* aFileName);
/**
* Returns true if the file exist.
*
......
ndb/src/common/logger/FileLogHandler.cpp
View file @ 99395d5d
......@@ -147,6 +147,7 @@ FileLogHandler::createNewFile()
bool rc = true;
int fileNo = 1;
char newName[PATH_MAX];
time_t newMtime, preMtime = 0;
do
{
......@@ -159,7 +160,15 @@ FileLogHandler::createNewFile()
}
BaseString::snprintf(newName, sizeof(newName),
"%s.%d", m_pLogFile->getName(), fileNo++);
newMtime = File_class::mtime(newName);
if (newMtime < preMtime)
{
break;
}
else
{
preMtime = newMtime;
}
} while (File_class::exists(newName));
m_pLogFile->close();
......
ndb/src/common/util/File.cpp
View file @ 99395d5d
......@@ -24,6 +24,18 @@
//
// PUBLIC
//
time_t
File_class::mtime(const char* aFileName)
{
MY_STAT stmp;
time_t rc = 0;
if (my_stat(aFileName, &stmp, MYF(0)) != NULL) {
rc = stmp.st_mtime;
}
return rc;
}
bool
File_class::exists(const char* aFileName)
......
ndb/src/kernel/blocks/dbdih/DbdihMain.cpp
View file @ 99395d5d
......@@ -6488,7 +6488,13 @@ void Dbdih::execCREATE_FRAGMENTATION_REQ(Signal * signal){
}//for
}
}
ndbrequire(count == (2 + noOfReplicas * noOfFragments));
if(count != (2 + noOfReplicas * noOfFragments)){
char buf[255];
BaseString::snprintf(buf, sizeof(buf),
"Illegal configuration change: NoOfReplicas."
" Can't be applied online ");
progError(__LINE__, NDBD_EXIT_INVALID_CONFIG, buf);
}
CreateFragmentationConf * const conf =
(CreateFragmentationConf*)signal->getDataPtrSend();
......
ndb/src/mgmapi/mgmapi.cpp
View file @ 99395d5d
......@@ -1300,6 +1300,45 @@ ndb_mgm_get_event_category_string(enum ndb_mgm_event_category status)
return 0;
}
static const char *clusterlog_names[]=
{ "startup", "shutdown", "statistics", "checkpoint", "noderestart", "connection", "info", "warning", "error", "congestion", "debug", "backup" };
extern "C"
const unsigned int *
ndb_mgm_get_clusterlog_loglevel(NdbMgmHandle handle)
{
SET_ERROR(handle, NDB_MGM_NO_ERROR, "Executing: ndb_mgm_get_clusterlog_loglevel");
int loglevel_count = CFG_MAX_LOGLEVEL - CFG_MIN_LOGLEVEL + 1 ;
static unsigned int loglevel[CFG_MAX_LOGLEVEL - CFG_MIN_LOGLEVEL + 1] = {0,0,0,0,0,0,0,0,0,0,0,0};
const ParserRow<ParserDummy> getloglevel_reply[] = {
MGM_CMD("get cluster loglevel", NULL, ""),
MGM_ARG(clusterlog_names[0], Int, Mandatory, ""),
MGM_ARG(clusterlog_names[1], Int, Mandatory, ""),
MGM_ARG(clusterlog_names[2], Int, Mandatory, ""),
MGM_ARG(clusterlog_names[3], Int, Mandatory, ""),
MGM_ARG(clusterlog_names[4], Int, Mandatory, ""),
MGM_ARG(clusterlog_names[5], Int, Mandatory, ""),
MGM_ARG(clusterlog_names[6], Int, Mandatory, ""),
MGM_ARG(clusterlog_names[7], Int, Mandatory, ""),
MGM_ARG(clusterlog_names[8], Int, Mandatory, ""),
MGM_ARG(clusterlog_names[9], Int, Mandatory, ""),
MGM_ARG(clusterlog_names[10], Int, Mandatory, ""),
MGM_ARG(clusterlog_names[11], Int, Mandatory, ""),
};
CHECK_HANDLE(handle, NULL);
CHECK_CONNECTED(handle, NULL);
Properties args;
const Properties *reply;
reply = ndb_mgm_call(handle, getloglevel_reply, "get cluster loglevel", &args);
CHECK_REPLY(reply, NULL);
for(int i=0; i < loglevel_count; i++) {
reply->get(clusterlog_names[i], &loglevel[i]);
}
return loglevel;
}
extern "C"
int
ndb_mgm_set_clusterlog_loglevel(NdbMgmHandle handle, int nodeId,
......
ndb/src/mgmclient/CommandInterpreter.cpp
View file @ 99395d5d
......@@ -68,10 +68,11 @@ 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);
void executeCommand(Vector<BaseString> &command_list,
int executeCommand(Vector<BaseString> &command_list,
unsigned command_pos,
int *node_ids, int no_of_nodes);
/**
......@@ -97,42 +98,42 @@ 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, bool interactive);
void executePurge(char* parameters);
int executeHelp(char* parameters);
int executeShow(char* parameters);
int executePurge(char* parameters);
int executeConnect(char* parameters, bool interactive);
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 executeStop(Vector<BaseString> &command_list, unsigned command_pos,
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 executeStop(Vector<BaseString> &command_list, unsigned command_pos,
int *node_ids, int no_of_nodes);
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 executeRestart(Vector<BaseString> &command_list, unsigned command_pos,
int executeRestart(Vector<BaseString> &command_list, unsigned command_pos,
int *node_ids, int no_of_nodes);
void executeLogLevel(int processId, const char* parameters, bool all);
void executeError(int processId, const char* parameters, bool all);
void executeLog(int processId, const char* parameters, bool all);
void executeLogIn(int processId, const char* parameters, bool all);
void executeLogOut(int processId, const char* parameters, bool all);
void executeLogOff(int processId, const char* parameters, bool all);
void executeTestOn(int processId, const char* parameters, bool all);
void executeTestOff(int processId, const char* parameters, bool all);
void executeSet(int processId, const char* parameters, bool all);
void executeGetStat(int processId, const char* parameters, bool all);
void executeStatus(int processId, const char* parameters, bool all);
void executeEventReporting(int processId, const char* parameters, bool all);
void executeDumpState(int processId, const char* parameters, bool all);
int executeStartBackup(char * parameters);
void executeAbortBackup(char * parameters);
void executeRep(char* parameters);
int executeRep(char* parameters);
void executeCpc(char * parameters);
......@@ -144,7 +145,7 @@ public:
* A execute function definition
*/
public:
typedef void (CommandInterpreter::* ExecuteFunction)(int processId,
typedef int (CommandInterpreter::* ExecuteFunction)(int processId,
const char * param,
bool all);
......@@ -156,7 +157,7 @@ private:
/**
*
*/
void executeForAll(const char * cmd,
int executeForAll(const char * cmd,
ExecuteFunction fun,
const char * param);
......@@ -969,6 +970,7 @@ CommandInterpreter::execute_impl(const char *_line, bool interactive)
char * line;
if(_line == NULL) {
m_error = -1;
DBUG_RETURN(false);
}
line = my_strdup(_line,MYF(MY_WME));
......@@ -1006,16 +1008,17 @@ CommandInterpreter::execute_impl(const char *_line, bool interactive)
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, interactive);
m_error = executeConnect(allAfterFirstToken, interactive);
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 ||
......@@ -1025,12 +1028,20 @@ CommandInterpreter::execute_impl(const char *_line, bool interactive)
DBUG_RETURN(false);
}
if (!connect(interactive))
if (!connect(interactive)){
m_error = -1;
DBUG_RETURN(true);
}
if (ndb_mgm_check_connection(m_mgmsrv))
{
disconnect();
connect(interactive);
}
if (strcasecmp(firstToken, "SHOW") == 0) {
Guard g(m_print_mutex);
executeShow(allAfterFirstToken);
m_error = executeShow(allAfterFirstToken);
DBUG_RETURN(true);
}
else if (strcasecmp(firstToken, "SHUTDOWN") == 0) {
......@@ -1050,17 +1061,17 @@ CommandInterpreter::execute_impl(const char *_line, bool interactive)
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
......@@ -1068,18 +1079,18 @@ CommandInterpreter::execute_impl(const char *_line, bool interactive)
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 tokens should be digits, node ID's
......@@ -1106,20 +1117,22 @@ CommandInterpreter::execute_impl(const char *_line, bool interactive)
{
/* No digit found */
invalid_command(_line);
m_error = -1;
DBUG_RETURN(true);
}
if (pos == command_list.size())
{
/* No command found */
invalid_command(_line);
m_error = -1;
DBUG_RETURN(true);
}
if (no_of_nodes == 1)
{
analyseAfterFirstToken(node_ids[0], allAfterFirstToken);
m_error = analyseAfterFirstToken(node_ids[0], allAfterFirstToken);
DBUG_RETURN(true);
}
executeCommand(command_list, pos, node_ids, no_of_nodes);
m_error = executeCommand(command_list, pos, node_ids, no_of_nodes);
DBUG_RETURN(true);
}
DBUG_RETURN(true);
......@@ -1153,14 +1166,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, " ");
......@@ -1179,36 +1193,39 @@ 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;
}
void
int
CommandInterpreter::executeCommand(Vector<BaseString> &command_list,
unsigned command_pos,
int *node_ids, int no_of_nodes)
{
const char *cmd= command_list[command_pos].c_str();
int retval = 0;
if (strcasecmp("STOP", cmd) == 0)
{
executeStop(command_list, command_pos+1, node_ids, no_of_nodes);
return;
retval = executeStop(command_list, command_pos+1, node_ids, no_of_nodes);
return retval;
}
if (strcasecmp("RESTART", cmd) == 0)
{
executeRestart(command_list, command_pos+1, node_ids, no_of_nodes);
return;
retval = executeRestart(command_list, command_pos+1, node_ids, no_of_nodes);
return retval;
}
ndbout_c("Invalid command: '%s' after multi node id list. "
"Expected STOP or RESTART.", cmd);
return;
return -1;
}
/**
......@@ -1249,18 +1266,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 {
......@@ -1269,12 +1288,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;
}
//*****************************************************************************
......@@ -1344,7 +1364,7 @@ CommandInterpreter::parseBlockSpecification(const char* allAfterLog,
/*****************************************************************************
* HELP
*****************************************************************************/
void
int
CommandInterpreter::executeHelp(char* parameters)
{
if (emptyString(parameters)) {
......@@ -1380,9 +1400,12 @@ CommandInterpreter::executeHelp(char* parameters)
break;
}
}
if (help_items[i].cmd == NULL)
if (help_items[i].cmd == NULL){
ndbout << "No help for " << parameters << " available" << endl;
return -1;
}
}
return 0;
}
......@@ -1505,7 +1528,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;
......@@ -1524,7 +1547,7 @@ CommandInterpreter::executePurge(char* parameters)
if (!command_ok) {
ndbout_c("Unexpected command, expected: PURGE STALE SESSIONS");
return;
return -1;
}
int i;
......@@ -1532,7 +1555,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);
......@@ -1542,9 +1565,10 @@ CommandInterpreter::executePurge(char* parameters)
{
ndbout_c("No sessions purged");
}
return 0;
}
void
int
CommandInterpreter::executeShow(char* parameters)
{
int i;
......@@ -1553,7 +1577,7 @@ CommandInterpreter::executeShow(char* parameters)
if(state == NULL) {
ndbout_c("Could not get status");
printError();
return;
return -1;
}
NdbAutoPtr<char> ap1((char*)state);
......@@ -1561,7 +1585,7 @@ CommandInterpreter::executeShow(char* parameters)
if(conf == 0){
ndbout_c("Could not get configuration");
printError();
return;
return -1;
}
ndb_mgm_configuration_iterator * it;
......@@ -1570,7 +1594,7 @@ CommandInterpreter::executeShow(char* parameters)
if(it == 0){
ndbout_c("Unable to create config iterator");
ndb_mgm_destroy_configuration(conf);
return;
return -1;
}
NdbAutoPtr<ndb_mgm_configuration_iterator> ptr(it);
......@@ -1604,7 +1628,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();
}
......@@ -1617,7 +1641,7 @@ CommandInterpreter::executeShow(char* parameters)
print_nodes(state, it, "mysqld", api_nodes, NDB_MGM_NODE_TYPE_API, 0);
// ndbout << helpTextShow;
ndb_mgm_destroy_configuration(conf);
return;
return 0;
} else if (strcasecmp(parameters, "PROPERTIES") == 0 ||
strcasecmp(parameters, "PROP") == 0) {
ndbout << "SHOW PROPERTIES is not yet implemented." << endl;
......@@ -1634,17 +1658,29 @@ CommandInterpreter::executeShow(char* parameters)
// << endl; /* XXX */
} else {
ndbout << "Invalid argument." << endl;
return -1;
}
return 0;
}
void
int
CommandInterpreter::executeConnect(char* parameters, bool interactive)
{
BaseString *basestring = NULL;
int retval;
disconnect();
if (!emptyString(parameters)) {
m_constr= BaseString(parameters).trim().c_str();
basestring= new BaseString(parameters);
m_constr= basestring->trim().c_str();
}
connect(interactive);
if ( connect(interactive) == false ){
return -1;
}
if (basestring != NULL)
delete basestring;
return 0;
}
//*****************************************************************************
......@@ -1657,6 +1693,7 @@ CommandInterpreter::executeClusterLog(char* parameters)
if (emptyString(parameters))
{
ndbout << "Missing argument." << endl;
m_error = -1;
DBUG_VOID_RETURN;
}
......@@ -1672,6 +1709,7 @@ CommandInterpreter::executeClusterLog(char* parameters)
if(enabled == NULL) {
ndbout << "Couldn't get status" << endl;
printError();
m_error = -1;
DBUG_VOID_RETURN;
}
......@@ -1683,6 +1721,7 @@ CommandInterpreter::executeClusterLog(char* parameters)
if(enabled[0] == 0)
{
ndbout << "Cluster logging is disabled." << endl;
m_error = 0;
DBUG_VOID_RETURN;
}
#if 0
......@@ -1701,6 +1740,7 @@ CommandInterpreter::executeClusterLog(char* parameters)
ndbout << BaseString(str).ndb_toupper() << " ";
}
ndbout << endl;
m_error = 0;
DBUG_VOID_RETURN;
}
......@@ -1719,6 +1759,7 @@ CommandInterpreter::executeClusterLog(char* parameters)
enable= 1;
} else {
ndbout << "Invalid argument." << endl;
m_error = -1;
DBUG_VOID_RETURN;
}
......@@ -1733,9 +1774,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;
}
......@@ -1762,6 +1805,7 @@ CommandInterpreter::executeClusterLog(char* parameters)
}
if (severity == NDB_MGM_ILLEGAL_EVENT_SEVERITY) {
ndbout << "Invalid severity level: " << item << endl;
m_error = -1;
DBUG_VOID_RETURN;
}
......@@ -1771,23 +1815,27 @@ 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 *parameters,
bool all)
{
int retval = 0;
Vector<BaseString> command_list;
if (parameters)
{
......@@ -1797,18 +1845,22 @@ CommandInterpreter::executeStop(int processId, const char *parameters,
command_list[i].c_str()[0] ? i++ : (command_list.erase(i),0);
}
if (all)
executeStop(command_list, 0, 0, 0);
retval = executeStop(command_list, 0, 0, 0);
else
executeStop(command_list, 0, &processId, 1);
retval = executeStop(command_list, 0, &processId, 1);
return retval;
}
void
int
CommandInterpreter::executeStop(Vector<BaseString> &command_list,
unsigned command_pos,
int *node_ids, int no_of_nodes)
{
int need_disconnect;
int abort= 0;
int retval = 0;
for (; command_pos < command_list.size(); command_pos++)
{
const char *item= command_list[command_pos].c_str();
......@@ -1819,7 +1871,7 @@ CommandInterpreter::executeStop(Vector<BaseString> &command_list,
}
ndbout_c("Invalid option: %s. Expecting -A after STOP",
item);
return;
return -1;
}
int result= ndb_mgm_stop3(m_mgmsrv, no_of_nodes, node_ids, abort,
......@@ -1828,6 +1880,7 @@ CommandInterpreter::executeStop(Vector<BaseString> &command_list,
{
ndbout_c("Shutdown failed.");
printError();
retval = -1;
}
else
{
......@@ -1848,9 +1901,10 @@ CommandInterpreter::executeStop(Vector<BaseString> &command_list,
disconnect();
}
return retval;
}
void
int
CommandInterpreter::executeEnterSingleUser(char* parameters)
{
strtok(parameters, " ");
......@@ -1862,37 +1916,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 {
......@@ -1902,6 +1961,7 @@ CommandInterpreter::executeStart(int processId, const char* parameters,
if (result <= 0) {
ndbout << "Start failed." << endl;
printError();
retval = -1;
} else
{
if(all)
......@@ -1909,13 +1969,16 @@ 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)
{
Vector<BaseString> command_list;
int retval = 0;
if (parameters)
{
BaseString tmp(parameters);
......@@ -1924,17 +1987,20 @@ CommandInterpreter::executeRestart(int processId, const char* parameters,
command_list[i].c_str()[0] ? i++ : (command_list.erase(i),0);
}
if (all)
executeRestart(command_list, 0, 0, 0);
retval = executeRestart(command_list, 0, 0, 0);
else
executeRestart(command_list, 0, &processId, 1);
retval = executeRestart(command_list, 0, &processId, 1);
return retval;
}
void
int
CommandInterpreter::executeRestart(Vector<BaseString> &command_list,
unsigned command_pos,
int *node_ids, int no_of_nodes)
{
int result;
int retval = 0;
int nostart= 0;
int initialstart= 0;
int abort= 0;
......@@ -1960,7 +2026,7 @@ CommandInterpreter::executeRestart(Vector<BaseString> &command_list,
}
ndbout_c("Invalid option: %s. Expecting -A,-N or -I after RESTART",
item);
return;
return -1;
}
result= ndb_mgm_restart3(m_mgmsrv, no_of_nodes, node_ids,
......@@ -1969,6 +2035,7 @@ CommandInterpreter::executeRestart(Vector<BaseString> &command_list,
if (result <= 0) {
ndbout_c("Restart failed.");
printError();
retval = -1;
}
else
{
......@@ -1984,15 +2051,16 @@ CommandInterpreter::executeRestart(Vector<BaseString> &command_list,
if(need_disconnect)
disconnect();
}
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;
......@@ -2009,7 +2077,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);
......@@ -2021,16 +2089,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;
......@@ -2042,7 +2110,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);
......@@ -2051,7 +2119,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;
......@@ -2075,27 +2143,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();
......@@ -2105,14 +2175,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;
......@@ -2128,20 +2198,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
......@@ -2152,29 +2224,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;
......@@ -2198,82 +2271,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
......@@ -2337,17 +2419,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
......@@ -2363,19 +2446,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;
......@@ -2422,10 +2507,12 @@ CommandInterpreter::executeEventReporting(int processId,
if (result != 0) {
ndbout_c(" failed.");
printError();
retval = -1;
} else {
ndbout_c(" OK!");
}
}
return retval;
}
/*****************************************************************************
......@@ -2526,7 +2613,7 @@ CommandInterpreter::executeStartBackup(char* parameters)
return 0;
}
void
int
CommandInterpreter::executeAbortBackup(char* parameters)
{
int bid = -1;
......@@ -2545,14 +2632,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
......@@ -2583,12 +2671,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));
......@@ -2608,7 +2696,7 @@ CommandInterpreter::executeRep(char* parameters)
if(host == NULL)
{
ndbout_c("host:port must be specified.");
return;
return -1;
}
if(rep_connected) {
......@@ -2620,14 +2708,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;
}
}
......@@ -2661,17 +2752,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;
}
/********
......@@ -2691,7 +2783,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);
......@@ -2715,16 +2807,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;
}
/*********
......@@ -2737,6 +2830,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;
......@@ -2744,7 +2838,7 @@ CommandInterpreter::executeRep(char* parameters)
ndbout << " SubscriptionId " << repstate.subid
<< " SubscriptionKey " << repstate.subkey << endl;
}
return;
return 0;
}
/*********
......@@ -2763,6 +2857,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"
......@@ -2771,8 +2866,9 @@ CommandInterpreter::executeRep(char* parameters)
repstate.first[0], repstate.last[0],
repstate.no_of_nodegroups );
}
return;
return 0;
}
return 0;
}
#endif // HAVE_GLOBAL_REPLICATION
......
ndb/src/mgmsrv/Services.cpp
View file @ 99395d5d
......@@ -147,6 +147,7 @@ ParserRow<MgmApiSession> commands[] = {
MGM_CMD("get status", &MgmApiSession::getStatus, ""),
MGM_CMD("get info clusterlog", &MgmApiSession::getInfoClusterLog, ""),
MGM_CMD("get cluster loglevel", &MgmApiSession::getClusterLogLevel, ""),
MGM_CMD("restart node", &MgmApiSession::restart_v1, ""),
MGM_ARG("node", String, Mandatory, "Nodes to restart"),
......@@ -803,6 +804,32 @@ MgmApiSession::endSession(Parser<MgmApiSession>::Context &,
m_output->println("end session reply");
}
void
MgmApiSession::getClusterLogLevel(Parser<MgmApiSession>::Context & , Properties const &) {
const char* names[] = { "startup",
"shutdown",
"statistics",
"checkpoint",
"noderestart",
"connection",
"info",
"warning",
"error",
"congestion",
"debug",
"backup" };
int loglevel_count = (CFG_MAX_LOGLEVEL - CFG_MIN_LOGLEVEL + 1) ;
LogLevel::EventCategory category;
m_output->println("get cluster loglevel");
for(int i = 0; i < loglevel_count; i++) {
category = (LogLevel::EventCategory) i;
m_output->println("%s: %d", names[i], m_mgmsrv.m_event_listner[0].m_logLevel.getLogLevel(category));
}
m_output->println("");
}
void
MgmApiSession::setClusterLogLevel(Parser<MgmApiSession>::Context &,
Properties const &args) {
......
ndb/src/mgmsrv/Services.hpp
View file @ 99395d5d
......@@ -87,6 +87,8 @@ public:
void bye(Parser_t::Context &ctx, const class Properties &args);
void endSession(Parser_t::Context &ctx, const class Properties &args);
void setLogLevel(Parser_t::Context &ctx, const class Properties &args);
void getClusterLogLevel(Parser_t::Context &ctx,
const class Properties &args);
void setClusterLogLevel(Parser_t::Context &ctx,
const class Properties &args);
void setLogFilter(Parser_t::Context &ctx, const class Properties &args);
......
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