Merge mysql.com:/home/stewart/Documents/MySQL/5.0/merge-queue (ee1969d2) · Commits · Software / OSDI20 Artifacts / mariadb

storage/ndb/include/mgmapi/mgmapi.h

+57 −0

Original line number	Diff line number	Diff line
		@@ -699,6 +699,28 @@ extern "C" {
		int ndb_mgm_stop2(NdbMgmHandle handle, int no_of_nodes,
		const int * node_list, int abort);

		/**
		* Stops cluster nodes
		*
		* @param handle Management handle.
		* @param no_of_nodes Number of database nodes to stop<br>
		* -1: All database and management nodes<br>
		* 0: All database nodes in cluster<br>
		* n: Stop the <var>n</var> node(s) specified in
		* the array node_list
		* @param node_list List of node IDs of database nodes to be stopped
		* @param abort Don't perform graceful stop,
		* but rather stop immediately
		* @param disconnect Returns true if you need to disconnect to apply
		* the stop command (e.g. stopping the mgm server
		* that handle is connected to)
		*
		* @return Number of nodes stopped (-1 on error).
		*/
		int ndb_mgm_stop3(NdbMgmHandle handle, int no_of_nodes,
		const int * node_list, int abort, int *disconnect);


		/**
		* Restart database nodes
		*
		@@ -738,6 +760,31 @@ extern "C" {
		const int * node_list, int initial,
		int nostart, int abort);

		/**
		* Restart nodes
		*
		* @param handle Management handle.
		* @param no_of_nodes Number of database nodes to be restarted:<br>
		* 0: Restart all database nodes in the cluster<br>
		* n: Restart the <var>n</var> node(s) specified in the
		* array node_list
		* @param node_list List of node IDs of database nodes to be restarted
		* @param initial Remove filesystem from restarting node(s)
		* @param nostart Don't actually start node(s) but leave them
		* waiting for start command
		* @param abort Don't perform graceful restart,
		* but rather restart immediately
		* @param disconnect Returns true if mgmapi client must disconnect from
		* server to apply the requested operation. (e.g.
		* restart the management server)
		*
		*
		* @return Number of nodes stopped (-1 on error).
		*/
		int ndb_mgm_restart3(NdbMgmHandle handle, int no_of_nodes,
		const int * node_list, int initial,
		int nostart, int abort, int *disconnect);

		/**
		* Start database nodes
		*
		@@ -1018,6 +1065,16 @@ extern "C" {
		*/
		Uint32 ndb_mgm_get_mgmd_nodeid(NdbMgmHandle handle);

		/**
		* Get the version of the mgm server we're talking to.
		* Designed to allow switching of protocol depending on version
		* so that new clients can speak to old servers in a compat mode
		*/
		int ndb_mgm_get_version(NdbMgmHandle handle,
		int major, int minor, int* build,
		int len, char* str);


		/**
		* Config iterator
		*/

storage/ndb/src/mgmapi/mgmapi.cpp

+213 −27

Original line number	Diff line number	Diff line
		@@ -27,6 +27,7 @@
		#include <mgmapi_debug.h>
		#include "mgmapi_configuration.hpp"
		#include <socket_io.h>
		#include <version.h>

		#include <NdbOut.hpp>
		#include <SocketServer.hpp>
		@@ -103,6 +104,9 @@ struct ndb_mgm_handle {
		#endif
		FILE *errstream;
		char *m_name;
		int mgmd_version_major;
		int mgmd_version_minor;
		int mgmd_version_build;
		};

		#define SET_ERROR(h, e, s) setError(h, e, __LINE__, s)
		@@ -174,6 +178,10 @@ ndb_mgm_create_handle()
		h->logfile = 0;
		#endif

		h->mgmd_version_major= -1;
		h->mgmd_version_minor= -1;
		h->mgmd_version_build= -1;

		DBUG_PRINT("info", ("handle=0x%x", (UintPtr)h));
		DBUG_RETURN(h);
		}
		@@ -367,8 +375,9 @@ ndb_mgm_call(NdbMgmHandle handle, const ParserRow<ParserDummy> *command_reply,
		* Print some info about why the parser returns NULL
		*/
		fprintf(handle->errstream,
		"Error in mgm protocol parser. cmd: >%s< status: %d curr: %d\n",
		cmd, (Uint32)ctx.m_status, ctx.m_currentToken);
		"Error in mgm protocol parser. cmd: >%s< status: %d curr: %s\n",
		cmd, (Uint32)ctx.m_status,
		(ctx.m_currentToken)?ctx.m_currentToken:"NULL");
		DBUG_PRINT("info",("ctx.status: %d, ctx.m_currentToken: %s",
		ctx.m_status, ctx.m_currentToken));
		}
		@@ -684,7 +693,11 @@ ndb_mgm_get_status(NdbMgmHandle handle)
		out.println("");

		char buf[1024];
		in.gets(buf, sizeof(buf));
		if(!in.gets(buf, sizeof(buf)))
		{
		SET_ERROR(handle, NDB_MGM_ILLEGAL_SERVER_REPLY, "Probably disconnected");
		return NULL;
		}
		if(buf[strlen(buf)-1] == '\n')
		buf[strlen(buf)-1] = '\0';

		@@ -693,7 +706,11 @@ ndb_mgm_get_status(NdbMgmHandle handle)
		return NULL;
		}

		in.gets(buf, sizeof(buf));
		if(!in.gets(buf, sizeof(buf)))
		{
		SET_ERROR(handle, NDB_MGM_ILLEGAL_SERVER_REPLY, "Probably disconnected");
		return NULL;
		}
		if(buf[strlen(buf)-1] == '\n')
		buf[strlen(buf)-1] = '\0';

		@@ -716,6 +733,13 @@ ndb_mgm_get_status(NdbMgmHandle handle)
		malloc(sizeof(ndb_mgm_cluster_state)+
		noOfNodes*(sizeof(ndb_mgm_node_state)+sizeof("000.000.000.000#")));

		if(!state)
		{
		SET_ERROR(handle, NDB_MGM_OUT_OF_MEMORY,
		"Allocating ndb_mgm_cluster_state");
		return NULL;
		}

		state->no_of_nodes= noOfNodes;
		ndb_mgm_node_state * ptr = &state->node_states[0];
		int nodeId = 0;
		@@ -725,7 +749,13 @@ ndb_mgm_get_status(NdbMgmHandle handle)
		}
		i = -1; ptr--;
		for(; i<noOfNodes; ){
		in.gets(buf, sizeof(buf));
		if(!in.gets(buf, sizeof(buf)))
		{
		free(state);
		SET_ERROR(handle, NDB_MGM_ILLEGAL_SERVER_REPLY,
		"Probably disconnected");
		return NULL;
		}
		tmp.assign(buf);

		if(tmp.trim() == ""){
		@@ -835,37 +865,81 @@ ndb_mgm_stop(NdbMgmHandle handle, int no_of_nodes, const int * node_list)
		return ndb_mgm_stop2(handle, no_of_nodes, node_list, 0);
		}


		extern "C"
		int
		ndb_mgm_stop2(NdbMgmHandle handle, int no_of_nodes, const int * node_list,
		int abort)
		{
		SET_ERROR(handle, NDB_MGM_NO_ERROR, "Executing: ndb_mgm_stop2");
		const ParserRow<ParserDummy> stop_reply[] = {
		int disconnect;
		return ndb_mgm_stop3(handle, no_of_nodes, node_list, abort, &disconnect);
		}


		extern "C"
		int
		ndb_mgm_stop3(NdbMgmHandle handle, int no_of_nodes, const int * node_list,
		int abort, int *disconnect)
		{
		SET_ERROR(handle, NDB_MGM_NO_ERROR, "Executing: ndb_mgm_stop3");
		const ParserRow<ParserDummy> stop_reply_v1[] = {
		MGM_CMD("stop reply", NULL, ""),
		MGM_ARG("stopped", Int, Optional, "No of stopped nodes"),
		MGM_ARG("result", String, Mandatory, "Error message"),
		MGM_END()
		};
		const ParserRow<ParserDummy> stop_reply_v2[] = {
		MGM_CMD("stop reply", NULL, ""),
		MGM_ARG("stopped", Int, Optional, "No of stopped nodes"),
		MGM_ARG("result", String, Mandatory, "Error message"),
		MGM_ARG("disconnect", Int, Mandatory, "Need to disconnect"),
		MGM_END()
		};

		CHECK_HANDLE(handle, -1);
		CHECK_CONNECTED(handle, -1);

		if(no_of_nodes < 0){
		if(handle->mgmd_version_build==-1)
		{
		char verstr[50];
		if(!ndb_mgm_get_version(handle,
		&(handle->mgmd_version_major),
		&(handle->mgmd_version_minor),
		&(handle->mgmd_version_build),
		sizeof(verstr),
		verstr))
		{
		return -1;
		}
		}
		int use_v2= ((handle->mgmd_version_major==5)
		&& (
		(handle->mgmd_version_minor==0 && handle->mgmd_version_build>=21)
		\|\|(handle->mgmd_version_minor==1 && handle->mgmd_version_build>=12)
		\|\|(handle->mgmd_version_minor>1)
		)
		)
		\|\| (handle->mgmd_version_major>5);

		if(no_of_nodes < -1){
		SET_ERROR(handle, NDB_MGM_ILLEGAL_NUMBER_OF_NODES,
		"Negative number of nodes requested to stop");
		return -1;
		}

		Uint32 stoppedNoOfNodes = 0;
		if(no_of_nodes == 0){
		if(no_of_nodes <= 0){
		/**
		* All database nodes should be stopped
		* All nodes should be stopped (all or just db)
		*/
		Properties args;
		args.put("abort", abort);
		if(use_v2)
		args.put("stop", (no_of_nodes==-1)?"mgm,db":"db");
		const Properties *reply;
		reply = ndb_mgm_call(handle, stop_reply, "stop all", &args);
		if(use_v2)
		reply = ndb_mgm_call(handle, stop_reply_v2, "stop all", &args);
		else
		reply = ndb_mgm_call(handle, stop_reply_v1, "stop all", &args);
		CHECK_REPLY(reply, -1);

		if(!reply->get("stopped", &stoppedNoOfNodes)){
		@@ -874,6 +948,10 @@ ndb_mgm_stop2(NdbMgmHandle handle, int no_of_nodes, const int * node_list,
		delete reply;
		return -1;
		}
		if(use_v2)
		reply->get("disconnect", (Uint32*)disconnect);
		else
		*disconnect= 0;
		BaseString result;
		reply->get("result", result);
		if(strcmp(result.c_str(), "Ok") != 0) {
		@@ -899,7 +977,11 @@ ndb_mgm_stop2(NdbMgmHandle handle, int no_of_nodes, const int * node_list,
		args.put("abort", abort);

		const Properties *reply;
		reply = ndb_mgm_call(handle, stop_reply, "stop", &args);
		if(use_v2)
		reply = ndb_mgm_call(handle, stop_reply_v2, "stop v2", &args);
		else
		reply = ndb_mgm_call(handle, stop_reply_v1, "stop", &args);

		CHECK_REPLY(reply, stoppedNoOfNodes);
		if(!reply->get("stopped", &stoppedNoOfNodes)){
		SET_ERROR(handle, NDB_MGM_STOP_FAILED,
		@@ -907,6 +989,10 @@ ndb_mgm_stop2(NdbMgmHandle handle, int no_of_nodes, const int * node_list,
		delete reply;
		return -1;
		}
		if(use_v2)
		reply->get("disconnect", (Uint32*)disconnect);
		else
		*disconnect= 0;
		BaseString result;
		reply->get("result", result);
		if(strcmp(result.c_str(), "Ok") != 0) {
		@@ -918,22 +1004,71 @@ ndb_mgm_stop2(NdbMgmHandle handle, int no_of_nodes, const int * node_list,
		return stoppedNoOfNodes;
		}

		extern "C"
		int
		ndb_mgm_restart(NdbMgmHandle handle, int no_of_nodes, const int *node_list)
		{
		SET_ERROR(handle, NDB_MGM_NO_ERROR, "Executing: ndb_mgm_restart");
		return ndb_mgm_restart2(handle, no_of_nodes, node_list, 0, 0, 0);
		}

		extern "C"
		int
		ndb_mgm_restart2(NdbMgmHandle handle, int no_of_nodes, const int * node_list,
		int initial, int nostart, int abort)
		{
		SET_ERROR(handle, NDB_MGM_NO_ERROR, "Executing: ndb_mgm_restart2");
		int disconnect;

		return ndb_mgm_restart3(handle, no_of_nodes, node_list, initial, nostart,
		abort, &disconnect);
		}

		extern "C"
		int
		ndb_mgm_restart3(NdbMgmHandle handle, int no_of_nodes, const int * node_list,
		int initial, int nostart, int abort, int *disconnect)
		{
		SET_ERROR(handle, NDB_MGM_NO_ERROR, "Executing: ndb_mgm_restart3");
		Uint32 restarted = 0;
		const ParserRow<ParserDummy> restart_reply[] = {
		const ParserRow<ParserDummy> restart_reply_v1[] = {
		MGM_CMD("restart reply", NULL, ""),
		MGM_ARG("result", String, Mandatory, "Error message"),
		MGM_ARG("restarted", Int, Optional, "No of restarted nodes"),
		MGM_END()
		};
		const ParserRow<ParserDummy> restart_reply_v2[] = {
		MGM_CMD("restart reply", NULL, ""),
		MGM_ARG("result", String, Mandatory, "Error message"),
		MGM_ARG("restarted", Int, Optional, "No of restarted nodes"),
		MGM_ARG("disconnect", Int, Optional, "Disconnect to apply"),
		MGM_END()
		};

		CHECK_HANDLE(handle, -1);
		CHECK_CONNECTED(handle, -1);

		if(handle->mgmd_version_build==-1)
		{
		char verstr[50];
		if(!ndb_mgm_get_version(handle,
		&(handle->mgmd_version_major),
		&(handle->mgmd_version_minor),
		&(handle->mgmd_version_build),
		sizeof(verstr),
		verstr))
		{
		return -1;
		}
		}
		int use_v2= ((handle->mgmd_version_major==5)
		&& (
		(handle->mgmd_version_minor==0 && handle->mgmd_version_build>=21)
		\|\|(handle->mgmd_version_minor==1 && handle->mgmd_version_build>=12)
		\|\|(handle->mgmd_version_minor>1)
		)
		)
		\|\| (handle->mgmd_version_major>5);

		if(no_of_nodes < 0){
		SET_ERROR(handle, NDB_MGM_RESTART_FAILED,
		"Restart requested of negative number of nodes");
		@@ -948,7 +1083,7 @@ ndb_mgm_restart2(NdbMgmHandle handle, int no_of_nodes, const int * node_list,
		const Properties *reply;
		const int timeout = handle->read_timeout;
		handle->read_timeout= 5601000; // 5 minutes
		reply = ndb_mgm_call(handle, restart_reply, "restart all", &args);
		reply = ndb_mgm_call(handle, restart_reply_v1, "restart all", &args);
		handle->read_timeout= timeout;
		CHECK_REPLY(reply, -1);

		@@ -984,7 +1119,10 @@ ndb_mgm_restart2(NdbMgmHandle handle, int no_of_nodes, const int * node_list,
		const Properties *reply;
		const int timeout = handle->read_timeout;
		handle->read_timeout= 5601000; // 5 minutes
		reply = ndb_mgm_call(handle, restart_reply, "restart node", &args);
		if(use_v2)
		reply = ndb_mgm_call(handle, restart_reply_v2, "restart node v2", &args);
		else
		reply = ndb_mgm_call(handle, restart_reply_v1, "restart node", &args);
		handle->read_timeout= timeout;
		if(reply != NULL) {
		BaseString result;
		@@ -995,20 +1133,16 @@ ndb_mgm_restart2(NdbMgmHandle handle, int no_of_nodes, const int * node_list,
		return -1;
		}
		reply->get("restarted", &restarted);
		if(use_v2)
		reply->get("disconnect", (Uint32*)disconnect);
		else
		*disconnect= 0;
		delete reply;
		}

		return restarted;
		}

		extern "C"
		int
		ndb_mgm_restart(NdbMgmHandle handle, int no_of_nodes, const int *node_list)
		{
		SET_ERROR(handle, NDB_MGM_NO_ERROR, "Executing: ndb_mgm_restart");
		return ndb_mgm_restart2(handle, no_of_nodes, node_list, 0, 0, 0);
		}

		static const char *clusterlog_severity_names[]=
		{ "enabled", "debug", "info", "warning", "error", "critical", "alert" };

		@@ -2340,4 +2474,56 @@ int ndb_mgm_end_session(NdbMgmHandle handle)
		DBUG_RETURN(0);
		}

		extern "C"
		int ndb_mgm_get_version(NdbMgmHandle handle,
		int major, int minor, int build, int len, char str)
		{
		DBUG_ENTER("ndb_mgm_get_version");
		CHECK_HANDLE(handle, 0);
		CHECK_CONNECTED(handle, 0);

		Properties args;

		const ParserRow<ParserDummy> reply[]= {
		MGM_CMD("version", NULL, ""),
		MGM_ARG("id", Int, Mandatory, "ID"),
		MGM_ARG("major", Int, Mandatory, "Major"),
		MGM_ARG("minor", Int, Mandatory, "Minor"),
		MGM_ARG("string", String, Mandatory, "String"),
		MGM_END()
		};

		const Properties *prop;
		prop = ndb_mgm_call(handle, reply, "get version", &args);
		CHECK_REPLY(prop, 0);

		Uint32 id;
		if(!prop->get("id",&id)){
		fprintf(handle->errstream, "Unable to get value\n");
		return 0;
		}
		*build= getBuild(id);

		if(!prop->get("major",(Uint32*)major)){
		fprintf(handle->errstream, "Unable to get value\n");
		return 0;
		}

		if(!prop->get("minor",(Uint32*)minor)){
		fprintf(handle->errstream, "Unable to get value\n");
		return 0;
		}

		BaseString result;
		if(!prop->get("string", result)){
		fprintf(handle->errstream, "Unable to get value\n");
		return 0;
		}

		strncpy(str, result.c_str(), len);

		delete prop;
		DBUG_RETURN(1);
		}

		template class Vector<const ParserRow<ParserDummy>*>;

storage/ndb/src/mgmclient/CommandInterpreter.cpp

+115 −124

Original line number	Diff line number	Diff line
		@@ -155,6 +155,7 @@ class CommandInterpreter {

		NdbMgmHandle m_mgmsrv;
		NdbMgmHandle m_mgmsrv2;
		const char *m_constr;
		bool m_connected;
		int m_verbose;
		int try_reconnect;
		@@ -335,22 +336,7 @@ convert(const char* s, int& val) {
		CommandInterpreter::CommandInterpreter(const char *_host,int verbose)
		: m_verbose(verbose)
		{
		m_mgmsrv = ndb_mgm_create_handle();
		if(m_mgmsrv == NULL) {
		ndbout_c("Cannot create handle to management server.");
		exit(-1);
		}
		m_mgmsrv2 = ndb_mgm_create_handle();
		if(m_mgmsrv2 == NULL) {
		ndbout_c("Cannot create 2:nd handle to management server.");
		exit(-1);
		}
		if (ndb_mgm_set_connectstring(m_mgmsrv, _host))
		{
		printError();
		exit(-1);
		}

		m_constr= _host;
		m_connected= false;
		m_event_thread= 0;
		try_reconnect = 0;
		@@ -362,8 +348,6 @@ CommandInterpreter::CommandInterpreter(const char *_host,int verbose)
		CommandInterpreter::~CommandInterpreter()
		{
		disconnect();
		ndb_mgm_destroy_handle(&m_mgmsrv);
		ndb_mgm_destroy_handle(&m_mgmsrv2);
		}

		static bool
		@@ -385,15 +369,14 @@ emptyString(const char* s)
		void
		CommandInterpreter::printError()
		{
		if (ndb_mgm_check_connection(m_mgmsrv))
		{
		m_connected= false;
		disconnect();
		}
		ndbout_c("* %5d: %s",
		ndb_mgm_get_latest_error(m_mgmsrv),
		ndb_mgm_get_latest_error_msg(m_mgmsrv));
		ndbout_c("* %s", ndb_mgm_get_latest_error_desc(m_mgmsrv));
		if (ndb_mgm_check_connection(m_mgmsrv))
		{
		disconnect();
		}
		}

		//*****************************************************************************
		@@ -440,10 +423,30 @@ bool
		CommandInterpreter::connect()
		{
		DBUG_ENTER("CommandInterpreter::connect");
		if(!m_connected)
		{
		if(!ndb_mgm_connect(m_mgmsrv, try_reconnect-1, 5, 1))

		if(m_connected)
		DBUG_RETURN(m_connected);

		m_mgmsrv = ndb_mgm_create_handle();
		if(m_mgmsrv == NULL) {
		ndbout_c("Cannot create handle to management server.");
		exit(-1);
		}
		m_mgmsrv2 = ndb_mgm_create_handle();
		if(m_mgmsrv2 == NULL) {
		ndbout_c("Cannot create 2:nd handle to management server.");
		exit(-1);
		}

		if (ndb_mgm_set_connectstring(m_mgmsrv, m_constr))
		{
		printError();
		exit(-1);
		}

		if(ndb_mgm_connect(m_mgmsrv, try_reconnect-1, 5, 1))
		DBUG_RETURN(m_connected); // couldn't connect, always false

		const char *host= ndb_mgm_get_connected_host(m_mgmsrv);
		unsigned port= ndb_mgm_get_connected_port(m_mgmsrv);
		BaseString constr;
		@@ -507,8 +510,7 @@ CommandInterpreter::connect()
		printf("Connected to Management Server at: %s:%d\n",
		host, port);
		}
		}
		}

		DBUG_RETURN(m_connected);
		}

		@@ -516,20 +518,18 @@ bool
		CommandInterpreter::disconnect()
		{
		DBUG_ENTER("CommandInterpreter::disconnect");

		if (m_event_thread) {
		void *res;
		do_event_thread= 0;
		NdbThread_WaitFor(m_event_thread, &res);
		NdbThread_Destroy(&m_event_thread);
		m_event_thread= 0;
		ndb_mgm_disconnect(m_mgmsrv2);
		ndb_mgm_destroy_handle(&m_mgmsrv2);
		}
		if (m_connected)
		{
		if (ndb_mgm_disconnect(m_mgmsrv) == -1) {
		ndbout_c("Could not disconnect from management server");
		printError();
		}
		ndb_mgm_destroy_handle(&m_mgmsrv);
		m_connected= false;
		}
		DBUG_RETURN(true);
		@@ -985,7 +985,8 @@ CommandInterpreter::executeShutdown(char* parameters)
		NdbAutoPtr<char> ap1((char*)state);

		int result = 0;
		result = ndb_mgm_stop(m_mgmsrv, 0, 0);
		int need_disconnect;
		result = ndb_mgm_stop3(m_mgmsrv, -1, 0, 0, &need_disconnect);
		if (result < 0) {
		ndbout << "Shutdown of NDB Cluster node(s) failed." << endl;
		printError();
		@@ -994,28 +995,11 @@ CommandInterpreter::executeShutdown(char* parameters)

		ndbout << result << " NDB Cluster node(s) have shutdown." << endl;

		int mgm_id= 0;
		mgm_id= ndb_mgm_get_mgmd_nodeid(m_mgmsrv);
		if (mgm_id == 0)
		{
		ndbout << "Unable to locate management server, "
		<< "shutdown manually with <id> STOP"
		if(need_disconnect) {
		ndbout << "Disconnecting to allow management server to shutdown."
		<< endl;
		return 1;
		}

		result = ndb_mgm_stop(m_mgmsrv, 1, &mgm_id);
		if (result <= 0) {
		ndbout << "Shutdown of NDB Cluster management server failed." << endl;
		printError();
		if (result == 0)
		return 1;
		return result;
		}

		m_connected= false;
		disconnect();
		ndbout << "NDB Cluster management server shutdown." << endl;
		}
		return 0;
		}

		@@ -1237,12 +1221,7 @@ CommandInterpreter::executeConnect(char* parameters)
		{
		disconnect();
		if (!emptyString(parameters)) {
		if (ndb_mgm_set_connectstring(m_mgmsrv,
		BaseString(parameters).trim().c_str()))
		{
		printError();
		return;
		}
		m_constr= BaseString(parameters).trim().c_str();
		}
		connect();
		}
		@@ -1407,6 +1386,7 @@ CommandInterpreter::executeStop(Vector<BaseString> &command_list,
		unsigned command_pos,
		int *node_ids, int no_of_nodes)
		{
		int need_disconnect;
		int abort= 0;
		for (; command_pos < command_list.size(); command_pos++)
		{
		@@ -1421,7 +1401,8 @@ CommandInterpreter::executeStop(Vector<BaseString> &command_list,
		return;
		}

		int result= ndb_mgm_stop2(m_mgmsrv, no_of_nodes, node_ids, abort);
		int result= ndb_mgm_stop3(m_mgmsrv, no_of_nodes, node_ids, abort,
		&need_disconnect);
		if (result < 0)
		{
		ndbout_c("Shutdown failed.");
		@@ -1439,6 +1420,13 @@ CommandInterpreter::executeStop(Vector<BaseString> &command_list,
		ndbout_c(" has shutdown.");
		}
		}

		if(need_disconnect)
		{
		ndbout << "Disconnecting to allow Management Server to shutdown" << endl;
		disconnect();
		}

		}

		void
		@@ -1529,6 +1517,7 @@ CommandInterpreter::executeRestart(Vector<BaseString> &command_list,
		int nostart= 0;
		int initialstart= 0;
		int abort= 0;
		int need_disconnect= 0;

		for (; command_pos < command_list.size(); command_pos++)
		{
		@@ -1553,8 +1542,8 @@ CommandInterpreter::executeRestart(Vector<BaseString> &command_list,
		return;
		}

		result= ndb_mgm_restart2(m_mgmsrv, no_of_nodes, node_ids,
		initialstart, nostart, abort);
		result= ndb_mgm_restart3(m_mgmsrv, no_of_nodes, node_ids,
		initialstart, nostart, abort, &need_disconnect);

		if (result <= 0) {
		ndbout_c("Restart failed.");
		@@ -1571,6 +1560,8 @@ CommandInterpreter::executeRestart(Vector<BaseString> &command_list,
		ndbout << " " << node_ids[i];
		ndbout_c(" is being restarted");
		}
		if(need_disconnect)
		disconnect();
		}
		}

storage/ndb/src/mgmsrv/MgmtSrvr.cpp

+64 −30

Original line number	Diff line number	Diff line
		@@ -60,9 +60,6 @@

		#include <SignalSender.hpp>

		extern bool g_StopServer;
		extern bool g_RestartServer;

		//#define MGM_SRV_DEBUG
		#ifdef MGM_SRV_DEBUG
		#define DEBUG(x) do ndbout << x << endl; while(0)
		@@ -937,6 +934,13 @@ int MgmtSrvr::sendStopMgmd(NodeId nodeId,
		* client connection to that mgmd and stop it that way.
		* This allows us to stop mgm servers when there isn't any real
		* distributed communication up.
		*
		* node_ids.size()==0 means to stop all DB nodes.
		* MGM nodes will NOT be stopped.
		*
		* If we work out we should be stopping or restarting ourselves,
		* we return <0 in stopSelf for restart, >0 for stop
		* and 0 for do nothing.
		*/

		int MgmtSrvr::sendSTOP_REQ(const Vector<NodeId> &node_ids,
		@@ -946,7 +950,8 @@ int MgmtSrvr::sendSTOP_REQ(const Vector<NodeId> &node_ids,
		bool stop,
		bool restart,
		bool nostart,
		bool initialStart)
		bool initialStart,
		int* stopSelf)
		{
		int error = 0;
		DBUG_ENTER("MgmtSrvr::sendSTOP_REQ");
		@@ -995,12 +1000,13 @@ int MgmtSrvr::sendSTOP_REQ(const Vector<NodeId> &node_ids,
		NodeId nodeId= 0;
		int use_master_node= 0;
		int do_send= 0;
		int do_stop_self= 0;
		*stopSelf= 0;
		NdbNodeBitmask nodes_to_stop;
		{
		for (unsigned i= 0; i < node_ids.size(); i++)
		{
		nodeId= node_ids[i];
		ndbout << "asked to stop " << nodeId << endl;
		if (getNodeType(nodeId) != NDB_MGM_NODE_TYPE_MGM)
		nodes_to_stop.set(nodeId);
		else if (nodeId != getOwnNodeId())
		@@ -1011,7 +1017,11 @@ int MgmtSrvr::sendSTOP_REQ(const Vector<NodeId> &node_ids,
		stoppedNodes.set(nodeId);
		}
		else
		do_stop_self= 1;;
		{
		ndbout << "which is me" << endl;
		*stopSelf= (restart)? -1 : 1;
		stoppedNodes.set(nodeId);
		}
		}
		}
		int no_of_nodes_to_stop= nodes_to_stop.count();
		@@ -1044,14 +1054,6 @@ int MgmtSrvr::sendSTOP_REQ(const Vector<NodeId> &node_ids,
		nodes.set(nodeId);
		}
		}
		nodeId= 0;
		while(getNextNodeId(&nodeId, NDB_MGM_NODE_TYPE_MGM))
		{
		if(nodeId==getOwnNodeId())
		continue;
		if(sendStopMgmd(nodeId, abort, stop, restart, nostart, initialStart)==0)
		stoppedNodes.set(nodeId);
		}
		}

		// now wait for the replies
		@@ -1143,11 +1145,9 @@ int MgmtSrvr::sendSTOP_REQ(const Vector<NodeId> &node_ids,
		DBUG_RETURN(SEND_OR_RECEIVE_FAILED);
		}
		}
		if (!error && do_stop_self)
		if (error && *stopSelf)
		{
		if (restart)
		g_RestartServer= true;
		g_StopServer= true;
		*stopSelf= 0;
		}
		DBUG_RETURN(error);
		}
		@@ -1157,7 +1157,7 @@ int MgmtSrvr::sendSTOP_REQ(const Vector<NodeId> &node_ids,
		*/

		int MgmtSrvr::stopNodes(const Vector<NodeId> &node_ids,
		int *stopCount, bool abort)
		int stopCount, bool abort, int stopSelf)
		{
		if (!abort)
		{
		@@ -1179,20 +1179,46 @@ int MgmtSrvr::stopNodes(const Vector<NodeId> &node_ids,
		false,
		false,
		false,
		false);
		false,
		stopSelf);
		if (stopCount)
		*stopCount= nodes.count();
		return ret;
		}

		int MgmtSrvr::shutdownMGM(int stopCount, bool abort, int stopSelf)
		{
		NodeId nodeId = 0;
		int error;

		while(getNextNodeId(&nodeId, NDB_MGM_NODE_TYPE_MGM))
		{
		if(nodeId==getOwnNodeId())
		continue;
		error= sendStopMgmd(nodeId, abort, true, false,
		false, false);
		if (error == 0)
		*stopCount++;
		}

		*stopSelf= 1;
		*stopCount++;

		return 0;
		}

		/*
		* Perform system shutdown
		* Perform DB nodes shutdown.
		* MGM servers are left in their current state
		*/

		int MgmtSrvr::stop(int * stopCount, bool abort)
		int MgmtSrvr::shutdownDB(int * stopCount, bool abort)
		{
		NodeBitmask nodes;
		Vector<NodeId> node_ids;

		int tmp;

		int ret = sendSTOP_REQ(node_ids,
		nodes,
		0,
		@@ -1200,7 +1226,8 @@ int MgmtSrvr::stop(int * stopCount, bool abort)
		true,
		false,
		false,
		false);
		false,
		&tmp);
		if (stopCount)
		*stopCount = nodes.count();
		return ret;
		@@ -1225,6 +1252,7 @@ int MgmtSrvr::enterSingleUser(int * stopCount, Uint32 singleUserNodeId)
		}
		NodeBitmask nodes;
		Vector<NodeId> node_ids;
		int stopSelf;
		int ret = sendSTOP_REQ(node_ids,
		nodes,
		singleUserNodeId,
		@@ -1232,7 +1260,8 @@ int MgmtSrvr::enterSingleUser(int * stopCount, Uint32 singleUserNodeId)
		false,
		false,
		false,
		false);
		false,
		&stopSelf);
		if (stopCount)
		*stopCount = nodes.count();
		return ret;
		@@ -1244,7 +1273,8 @@ int MgmtSrvr::enterSingleUser(int * stopCount, Uint32 singleUserNodeId)

		int MgmtSrvr::restartNodes(const Vector<NodeId> &node_ids,
		int * stopCount, bool nostart,
		bool initialStart, bool abort)
		bool initialStart, bool abort,
		int *stopSelf)
		{
		NodeBitmask nodes;
		int ret= sendSTOP_REQ(node_ids,
		@@ -1254,7 +1284,8 @@ int MgmtSrvr::restartNodes(const Vector<NodeId> &node_ids,
		false,
		true,
		true,
		initialStart);
		initialStart,
		stopSelf);

		if (ret)
		return ret;
		@@ -1297,14 +1328,16 @@ int MgmtSrvr::restartNodes(const Vector<NodeId> &node_ids,
		}

		/*
		* Perform system restart
		* Perform restart of all DB nodes
		*/

		int MgmtSrvr::restart(bool nostart, bool initialStart,
		int MgmtSrvr::restartDB(bool nostart, bool initialStart,
		bool abort, int * stopCount)
		{
		NodeBitmask nodes;
		Vector<NodeId> node_ids;
		int tmp;

		int ret = sendSTOP_REQ(node_ids,
		nodes,
		0,
		@@ -1312,7 +1345,8 @@ int MgmtSrvr::restart(bool nostart, bool initialStart,
		true,
		true,
		true,
		initialStart);
		initialStart,
		&tmp);

		if (ret)
		return ret;

storage/ndb/src/mgmsrv/MgmtSrvr.hpp

+13 −9

File changed.

Preview size limit exceeded, changes collapsed.