removed more duplicated commands for management server (1780c9b3) · Commits · Software / OSDI20 Artifacts / mariadb

ndb/src/mgmclient/CommandInterpreter.cpp

+0 −38

Original line number	Diff line number	Diff line
		@@ -110,7 +110,6 @@ class CommandInterpreter {
		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 executeTrace(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);
		@@ -729,7 +728,6 @@ static const CommandInterpreter::CommandFunctionPair commands[] = {
		#ifdef ERROR_INSERT
		,{ "ERROR", &CommandInterpreter::executeError }
		#endif
		,{ "TRACE", &CommandInterpreter::executeTrace }
		,{ "LOG", &CommandInterpreter::executeLog }
		,{ "LOGIN", &CommandInterpreter::executeLogIn }
		,{ "LOGOUT", &CommandInterpreter::executeLogOut }
		@@ -1676,42 +1674,6 @@ void CommandInterpreter::executeError(int processId,
		ndb_mgm_insert_error(m_mgmsrv, processId, errorNo, NULL);
		}

		//*****************************************************************************
		//*****************************************************************************
		void
		CommandInterpreter::executeTrace(int /processId/,
		const char* /parameters/, bool /all/)
		{
		#if 0
		if (emptyString(parameters)) {
		ndbout << "Missing trace number." << endl;
		return;
		}

		char* newpar = my_strdup(parameters,MYF(MY_WME));
		My_auto_ptr<char> ap1(newpar);
		char* firstParameter = strtok(newpar, " ");


		int traceNo;
		if (! convert(firstParameter, traceNo)) {
		ndbout << "Expected an integer." << endl;
		return;
		}
		char* allAfterFirstParameter = strtok(NULL, "\0");

		if (! emptyString(allAfterFirstParameter)) {
		ndbout << "Nothing expected after trace number." << endl;
		return;
		}

		int result = _mgmtSrvr.setTraceNo(processId, traceNo);
		if (result != 0) {
		ndbout << get_error_text(result) << endl;
		}
		#endif
		}

		//*****************************************************************************
		//*****************************************************************************

ndb/src/mgmsrv/CommandInterpreter.cpp

+7 −293

Original line number	Diff line number	Diff line
		@@ -104,7 +104,6 @@ int CommandInterpreter::readAndExecute() {
		int processId;
		if (! convert(firstToken, processId)) {
		ndbout << "Invalid command: " << _line << "." << endl;
		ndbout << "Type HELP for help." << endl << endl;
		return true;
		}
		if (processId < 0) {
		@@ -120,20 +119,9 @@ int CommandInterpreter::readAndExecute() {


		static const CommandInterpreter::CommandFunctionPair commands[] = {
		{ "START", &CommandInterpreter::executeStart }
		,{ "RESTART", &CommandInterpreter::executeRestart }
		,{ "STOP", &CommandInterpreter::executeStop }
		#ifdef ERROR_INSERT
		,{ "ERROR", &CommandInterpreter::executeError }
		#endif
		,{ "TRACE", &CommandInterpreter::executeTrace }
		,{ "LOG", &CommandInterpreter::executeLog }
		,{ "LOGIN", &CommandInterpreter::executeLogIn }
		{ "LOGIN", &CommandInterpreter::executeLogIn }
		,{ "LOGOUT", &CommandInterpreter::executeLogOut }
		,{ "LOGOFF", &CommandInterpreter::executeLogOff }
		,{ "TESTON", &CommandInterpreter::executeTestOn }
		,{ "TESTOFF", &CommandInterpreter::executeTestOff }
		,{ "DUMP", &CommandInterpreter::executeDumpState }
		};


		@@ -170,14 +158,12 @@ CommandInterpreter::analyseAfterFirstToken(int processId,

		if(fun == 0){
		ndbout << "Invalid command: " << secondToken << "." << endl;
		ndbout << "Type HELP for help." << endl << endl;
		return;
		}

		if(processId == -1){
		executeForAll(command, fun, allAfterSecondToken);
		} else {
		if(strcmp(command, "STATUS") != 0)
		ndbout << "Executing " << command << " on node: "
		<< processId << endl << endl;
		(this->*fun)(processId, allAfterSecondToken, false);
		@@ -190,18 +176,11 @@ CommandInterpreter::executeForAll(const char * cmd, ExecuteFunction fun,
		const char * allAfterSecondToken){

		NodeId nodeId = 0;
		if(strcmp(cmd, "STOP") == 0 \|\|
		strcmp(cmd, "RESTART") == 0){
		ndbout << "Executing " << cmd << " on all nodes" << endl << "\n";
		(this->*fun)(nodeId, allAfterSecondToken, true);
		} else {
		while(_mgmtSrvr.getNextNodeId(&nodeId, NDB_MGM_NODE_TYPE_NDB)){
		if(strcmp(cmd, "STATUS") != 0)
		ndbout << "Executing " << cmd << " on node: "
		<< nodeId << endl << endl;
		(this->*fun)(nodeId, allAfterSecondToken, true);
		ndbout << endl;
		} // for
		}
		}

		@@ -271,233 +250,6 @@ bool CommandInterpreter::parseBlockSpecification(const char* allAfterLog,
		return true;
		}

		//*****************************************************************************
		//*****************************************************************************

		void
		stopCallback(int nodeId, void * anyData, int errCode){
		if(errCode == 0){
		if(nodeId == 0)
		ndbout << "\nCluster has shutdown" << endl;
		else
		ndbout << "\nNode " << nodeId << " has shutdown" << endl;
		} else {
		MgmtSrvr * mgm = (MgmtSrvr *)anyData;
		char err_str[1024];
		ndbout << "Node " << nodeId << " has not shutdown: "
		<< mgm->getErrorText(errCode,err_str,sizeof(err_str)) << endl;
		}
		}

		//*****************************************************************************
		//*****************************************************************************
		void CommandInterpreter::executeStop(int processId,
		const char* parameters, bool all) {

		(void)parameters; // Don't want compiler warning

		int result = 0;
		if(all)
		result = _mgmtSrvr.stop((int *)0, false, stopCallback, this);
		else
		result = _mgmtSrvr.stopNode(processId, false, stopCallback, this);

		if(result != 0)
		ndbout << get_error_text(result) << endl;
		}


		void CommandInterpreter::executeStart(int processId, const char* parameters,
		bool all) {
		(void)all; // Don't want compiler warning

		if (! emptyString(parameters)) {
		ndbout << "No parameters expected to this command." << endl;
		return;
		}

		int result = _mgmtSrvr.start(processId);
		if (result != 0) {
		ndbout << get_error_text(result) << endl;
		}
		}

		void
		CommandInterpreter::executeRestart(int processId, const char* parameters,
		bool all) {

		bool nostart = false;
		bool initialstart = false;

		if(parameters != 0 && strlen(parameters) != 0){
		char * tmpString = strdup(parameters);
		char * tmpPtr = 0;
		char * item = strtok_r(tmpString, " ", &tmpPtr);
		while(item != NULL){
		if(strcmp(item, "-N") == 0)
		nostart = true;
		if(strcmp(item, "-I") == 0)
		initialstart = true;
		item = strtok_r(NULL, " ", &tmpPtr);
		}
		free(tmpString);
		}
		int result;
		if(all)
		result = _mgmtSrvr.restart(nostart, initialstart, false,
		0, stopCallback, this);
		else
		result = _mgmtSrvr.restartNode(processId, nostart, initialstart, false,
		stopCallback,
		this);
		if (result != 0) {
		ndbout << get_error_text(result) << endl;
		}
		}

		void
		CommandInterpreter::executeDumpState(int processId, const char* parameters,
		bool all) {

		(void)all; // Don't want compiler warning

		if(parameters == 0 \|\| strlen(parameters) == 0){
		ndbout << "Expected argument" << endl;
		return;
		}

		Uint32 no = 0;
		Uint32 pars[25];

		char * tmpString = strdup(parameters);
		char * tmpPtr = 0;
		char * item = strtok_r(tmpString, " ", &tmpPtr);
		int error;
		while(item != NULL){
		if (0x0 <= my_strtoll10(item, NULL, &error) && my_strtoll10(item, NULL, &error) <= 0xffffffff) {
		pars[no] = my_strtoll10(item, NULL, &error);
		} else {
		ndbout << "Illegal value in argument to signal." << endl
		<< "(Value must be between 0 and 0xffffffff.)"
		<< endl;
		return;
		}
		no++;
		item = strtok_r(NULL, " ", &tmpPtr);
		}
		ndbout << "Sending dump signal with data:" << endl;
		for (Uint32 i=0; i<no; i++) {
		ndbout.setHexFormat(1) << pars[i] << " ";
		if (!(i+1 & 0x3)) ndbout << endl;
		}
		free(tmpString);
		int result = _mgmtSrvr.dumpState(processId, pars, no);
		if (result != 0) {
		ndbout << get_error_text(result) << endl;
		}
		}

		//*****************************************************************************
		//*****************************************************************************
		void CommandInterpreter::executeError(int processId,
		const char* parameters, bool all) {

		(void)all; // Don't want compiler warning

		if (emptyString(parameters)) {
		ndbout << "Missing error number." << endl;
		return;
		}
		// Copy parameters since strtok will modify it
		char* newpar = strdup(parameters);
		char* firstParameter = strtok(newpar, " ");

		int errorNo;
		if (! convert(firstParameter, errorNo)) {
		ndbout << "Expected an integer." << endl;
		free(newpar);
		return;
		}

		char* allAfterFirstParameter = strtok(NULL, "\0");
		if (! emptyString(allAfterFirstParameter)) {
		ndbout << "Nothing expected after error number." << endl;
		free(newpar);
		return;
		}

		int result = _mgmtSrvr.insertError(processId, errorNo);
		if (result != 0) {
		ndbout << get_error_text(result) << endl;
		}
		free(newpar);
		}



		//******************************************************************************
		//******************************************************************************
		void CommandInterpreter::executeTrace(int processId,
		const char* parameters, bool all) {

		(void)all; // Don't want compiler warning

		if (emptyString(parameters)) {
		ndbout << "Missing trace number." << endl;
		return;
		}

		char* newpar = strdup(parameters);
		char* firstParameter = strtok(newpar, " ");


		int traceNo;
		if (! convert(firstParameter, traceNo)) {
		ndbout << "Expected an integer." << endl;
		free(newpar);
		return;
		}

		char* allAfterFirstParameter = strtok(NULL, "\0");

		if (! emptyString(allAfterFirstParameter)) {
		ndbout << "Nothing expected after trace number." << endl;
		free(newpar);
		return;
		}

		int result = _mgmtSrvr.setTraceNo(processId, traceNo);
		if (result != 0) {
		ndbout << get_error_text(result) << endl;
		}
		free(newpar);
		}



		//******************************************************************************
		//******************************************************************************
		void CommandInterpreter::executeLog(int processId,
		const char* parameters, bool all) {

		(void)all; // Don't want compiler warning

		Vector<BaseString> blocks;
		if (! parseBlockSpecification(parameters, blocks)) {
		return;
		}

		int result = _mgmtSrvr.setSignalLoggingMode(processId, MgmtSrvr::InOut, blocks);
		if (result != 0) {
		ndbout << get_error_text(result) << endl;
		}

		}



		//******************************************************************************
		//******************************************************************************
		void CommandInterpreter::executeLogIn(int processId,
		const char* parameters, bool all) {

		@@ -554,41 +306,3 @@ void CommandInterpreter::executeLogOff(int processId,
		}

		}

		//******************************************************************************
		//******************************************************************************
		void CommandInterpreter::executeTestOn(int processId,
		const char* parameters, bool all) {

		(void)all; // Don't want compiler warning

		if (! emptyString(parameters)) {
		ndbout << "No parameters expected to this command." << endl;
		return;
		}

		int result = _mgmtSrvr.startSignalTracing(processId);
		if (result != 0) {
		ndbout << get_error_text(result) << endl;
		}

		}

		//******************************************************************************
		//******************************************************************************
		void CommandInterpreter::executeTestOff(int processId,
		const char* parameters, bool all) {

		(void)all; // Don't want compiler warning

		if (! emptyString(parameters)) {
		ndbout << "No parameters expected to this command." << endl;
		return;
		}

		int result = _mgmtSrvr.stopSignalTracing(processId);
		if (result != 0) {
		ndbout << get_error_text(result) << endl;
		}

		}

ndb/src/mgmsrv/CommandInterpreter.hpp

+0 −77

Original line number	Diff line number	Diff line
		@@ -17,52 +17,21 @@
		#ifndef CommandInterpreter_H
		#define CommandInterpreter_H

		//*****************************************************************************
		// Author: Peter Lind
		//*****************************************************************************

		#include <ndb_global.h>
		#include <Vector.hpp>
		#include <BaseString.hpp>

		class MgmtSrvr;

		/**
		* @class CommandInterpreter
		* @brief Reads command line in management client
		*
		* This class has one public method which reads a command line
		* from a stream. It then interpret that commmand line and calls a suitable
		* method in the MgmtSrvr class which executes the command.
		*
		* For command syntax, see the HELP command.
		*/
		class CommandInterpreter {
		public:
		/**
		* Constructor
		* @param mgmtSrvr: Management server to use when executing commands
		*/
		CommandInterpreter(MgmtSrvr& mgmtSrvr);

		/**
		* Reads one line from the stream, parse the line to find
		* a command and then calls a suitable method which executes
		* the command.
		*
		* @return true until quit/bye/exit has been typed
		*/
		int readAndExecute();

		private:
		char m_err_str[1024];
		const char *get_error_text(int err_no);

		/**
		* Read a string, and return a pointer to it.
		*
		* @return NULL on EOF.
		*/
		char *readline_gets ()
		{
		static char linebuffer[254];
		@@ -89,61 +58,15 @@ private:
		return (line_read);
		}

		/**
		* Analyse the command line, after the first token.
		*
		* @param processId: DB process id to send command to or -1 if
		* command will be sent to all DB processes.
		* @param allAfterFirstToken: What the client gave after the
		* first token on the command line
		*/
		void analyseAfterFirstToken(int processId, char* allAfterFirstTokenCstr);

		/**
		* Parse the block specification part of the LOG* commands,
		* things after LOG*: [BLOCK = {ALL\|<blockName>+}]
		*
		* @param allAfterLog: What the client gave after the second token
		* (LOG*) on the command line
		* @param blocks, OUT: ALL or name of all the blocks
		* @return: true if correct syntax, otherwise false
		*/
		bool parseBlockSpecification(const char* allAfterLog,
		Vector<BaseString>& blocks);

		/**
		* A bunch of execute functions: Executes one of the commands
		*
		* @param processId: DB process id to send command to
		* @param parameters: What the client gave after the command name
		* on the command line.
		* For example if complete input from user is: "1 LOGLEVEL 22" then the
		* parameters argument is the string with everything after LOGLEVEL, in this
		* case "22". Each function is responsible to check the parameters argument.
		*/
		void executeHelp(char* parameters);
		void executeShow(char* parameters);
		void executeRun(char* parameters);
		void executeInfo(char* parameters);

		public:
		void executeStop(int processId, const char* parameters, bool all);
		void executeStart(int processId, const char* parameters, bool all);
		void executeRestart(int processId, const char* parameters, bool all);
		void executeError(int processId, const char* parameters, bool all);
		void executeTrace(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 executeStatus(int processId, const char* parameters, bool all);
		void executeDumpState(int processId, const char* parameters, bool all);

		/**
		* A execute function definition
		*/
		public:
		typedef void (CommandInterpreter::* ExecuteFunction)(int processId,
		const char * param,