Merge mysql.com:/home/stewart/Documents/MySQL/5.0/jonas (8a7e206d) · Commits · Software / OSDI20 Artifacts / mariadb

ndb/include/mgmapi/mgmapi.h

+57 −0

Original line number	Diff line number	Diff line
		@@ -700,6 +700,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
		*
		@@ -739,6 +761,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
		*
		@@ -1029,6 +1076,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
		*/

ndb/src/mgmapi/mgmapi.cpp

+186 −22

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)
		@@ -168,6 +172,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);
		}
		@@ -851,37 +859,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)){
		@@ -890,6 +942,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) {
		@@ -915,7 +971,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,
		@@ -923,6 +983,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) {
		@@ -934,22 +998,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");
		@@ -964,7 +1077,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);

		@@ -1000,7 +1113,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;
		@@ -1011,20 +1127,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" };

		@@ -2383,4 +2495,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>*>;

ndb/src/mgmclient/CommandInterpreter.cpp

+115 −124

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

		NdbMgmHandle m_mgmsrv;
		NdbMgmHandle m_mgmsrv2;
		const char *m_constr;
		bool m_connected;
		int m_verbose;
		int try_reconnect;
		@@ -390,22 +391,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;
		@@ -422,8 +408,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
		@@ -445,15 +429,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();
		}
		}

		//*****************************************************************************
		@@ -500,10 +483,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;
		@@ -567,8 +570,7 @@ CommandInterpreter::connect()
		printf("Connected to Management Server at: %s:%d\n",
		host, port);
		}
		}
		}

		DBUG_RETURN(m_connected);
		}

		@@ -576,20 +578,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);
		@@ -1057,7 +1057,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();
		@@ -1066,28 +1067,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;
		}

		@@ -1311,12 +1295,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();
		}
		@@ -1481,6 +1460,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++)
		{
		@@ -1495,7 +1475,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.");
		@@ -1513,6 +1494,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
		@@ -1603,6 +1591,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++)
		{
		@@ -1627,8 +1616,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.");
		@@ -1645,6 +1634,8 @@ CommandInterpreter::executeRestart(Vector<BaseString> &command_list,
		ndbout << " " << node_ids[i];
		ndbout_c(" is being restarted");
		}
		if(need_disconnect)
		disconnect();
		}
		}

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)
		@@ -933,6 +930,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,
		@@ -942,7 +946,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");
		@@ -991,12 +996,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())
		@@ -1007,7 +1013,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();
		@@ -1040,14 +1050,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
		@@ -1139,11 +1141,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);
		}
		@@ -1153,7 +1153,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)
		{
		@@ -1175,20 +1175,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,
		@@ -1196,7 +1222,8 @@ int MgmtSrvr::stop(int * stopCount, bool abort)
		true,
		false,
		false,
		false);
		false,
		&tmp);
		if (stopCount)
		*stopCount = nodes.count();
		return ret;
		@@ -1221,6 +1248,7 @@ int MgmtSrvr::enterSingleUser(int * stopCount, Uint32 singleUserNodeId)
		}
		NodeBitmask nodes;
		Vector<NodeId> node_ids;
		int stopSelf;
		int ret = sendSTOP_REQ(node_ids,
		nodes,
		singleUserNodeId,
		@@ -1228,7 +1256,8 @@ int MgmtSrvr::enterSingleUser(int * stopCount, Uint32 singleUserNodeId)
		false,
		false,
		false,
		false);
		false,
		&stopSelf);
		if (stopCount)
		*stopCount = nodes.count();
		return ret;
		@@ -1240,7 +1269,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,
		@@ -1250,7 +1280,8 @@ int MgmtSrvr::restartNodes(const Vector<NodeId> &node_ids,
		false,
		true,
		true,
		initialStart);
		initialStart,
		stopSelf);

		if (ret)
		return ret;
		@@ -1293,14 +1324,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,
		@@ -1308,7 +1341,8 @@ int MgmtSrvr::restart(bool nostart, bool initialStart,
		true,
		true,
		true,
		initialStart);
		initialStart,
		&tmp);

		if (ret)
		return ret;

ndb/src/mgmsrv/MgmtSrvr.hpp

+13 −9

Original line number	Diff line number	Diff line
		@@ -255,12 +255,15 @@ public:
		* @param processId: Id of the DB process to stop
		* @return 0 if succeeded, otherwise: as stated above, plus:
		*/
		int stopNodes(const Vector<NodeId> &node_ids, int *stopCount, bool abort);
		int stopNodes(const Vector<NodeId> &node_ids, int *stopCount, bool abort,
		int *stopSelf);

		int shutdownMGM(int stopCount, bool abort, int stopSelf);

		/**
		* Stop the system
		* shutdown the DB nodes
		*/
		int stop(int * cnt = 0, bool abort = false);
		int shutdownDB(int * cnt = 0, bool abort = false);

		/**
		* print version info about a node
		@@ -294,12 +297,12 @@ public:
		*/
		int restartNodes(const Vector<NodeId> &node_ids,
		int *stopCount, bool nostart,
		bool initialStart, bool abort);
		bool initialStart, bool abort, int *stopSelf);

		/**
		* Restart the system
		* Restart all DB nodes
		*/
		int restart(bool nostart, bool initialStart,
		int restartDB(bool nostart, bool initialStart,
		bool abort = false,
		int * stopCount = 0);

		@@ -507,7 +510,8 @@ private:
		bool stop,
		bool restart,
		bool nostart,
		bool initialStart);
		bool initialStart,
		int *stopSelf);

		/**
		* Check if it is possible to send a signal to a (DB) process