reengineered ndb_mgmd to use SignalSender and remove some multi user issues

ndb/include/kernel/GlobalSignalNumbers.h

@@ -553,7 +553,6 @@ extern const GlobalSignalNumber NO_OF_SIGNAL_NAMES;
 #define GSN_STATISTICS_CONF             454
 
 #define GSN_START_ORD                   455
-/* 456 unused */
 /* 457 unused */
 
 #define GSN_EVENT_SUBSCRIBE_REQ         458
@@ -900,6 +899,7 @@ extern const GlobalSignalNumber NO_OF_SIGNAL_NAMES;
 #define GSN_RESUME_REQ                  682
 #define GSN_STOP_REQ                    443
 #define GSN_STOP_REF                    444
+#define GSN_STOP_CONF                   456
 #define GSN_API_VERSION_REQ             697
 #define GSN_API_VERSION_CONF            698
 

ndb/include/kernel/signaldata/EventReport.hpp

@@ -133,9 +133,9 @@ public:
     CreateLogBytes = 48,
     InfoEvent = 49,
 
-    //GREP
-    GrepSubscriptionInfo = 52,
-    GrepSubscriptionAlert = 53,
+    // SINGLE USER
+    SingleUser = 52,
+    /* unused 53 */
 
     //BACKUP
     BackupStarted = 54,

ndb/include/kernel/signaldata/StopReq.hpp

@@ -67,6 +67,13 @@ public:
   static bool getStopAbort(const Uint32 & requestInfo);
 };
 
+struct StopConf
+{
+  STATIC_CONST( SignalLength = 2 );
+  Uint32 senderData;
+  Uint32 nodeState;
+};
+
 class StopRef 
 {
   /**
@@ -86,7 +93,8 @@ public:
     OK = 0,
     NodeShutdownInProgress = 1,
     SystemShutdownInProgress = 2,
-    NodeShutdownWouldCauseSystemCrash = 3
+    NodeShutdownWouldCauseSystemCrash = 3,
+    TransactionAbortFailed = 4
   };
   
 public:

ndb/src/kernel/blocks/ndbcntr/NdbcntrMain.cpp

@@ -1966,6 +1966,11 @@ Ndbcntr::execRESUME_REQ(Signal* signal){
   //ResumeRef * const ref = (ResumeRef *)&signal->theData[0];
   
   jamEntry();
+
+  signal->theData[0] = EventReport::SingleUser;
+  signal->theData[1] = 2;
+  sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 2, JBB);
+
   //Uint32 senderData = req->senderData;
   //BlockReference senderRef = req->senderRef;
   NodeState newState(NodeState::SL_STARTED);		  
@@ -2004,12 +2009,11 @@ Ndbcntr::execSTOP_REQ(Signal* signal){
     return;
   }
 
-  if(c_stopRec.stopReq.senderRef != 0 && !singleuser){
-    jam();
+  if(c_stopRec.stopReq.senderRef != 0){
     /**
      * Requested a system shutdown
      */
-    if(StopReq::getSystemStop(req->requestInfo)){
+    if(!singleuser && StopReq::getSystemStop(req->requestInfo)){
       jam();
       sendSignalWithDelay(reference(), GSN_STOP_REQ, signal, 100,
 			  StopReq::SignalLength);
@@ -2031,22 +2035,27 @@ Ndbcntr::execSTOP_REQ(Signal* signal){
   c_stopRec.stopReq = * req;
   c_stopRec.stopInitiatedTime = NdbTick_CurrentMillisecond();
   
-  if(StopReq::getSystemStop(c_stopRec.stopReq.requestInfo) && !singleuser) {
+  if(!singleuser) {
+    if(StopReq::getSystemStop(c_stopRec.stopReq.requestInfo)) {
       jam();
       if(StopReq::getPerformRestart(c_stopRec.stopReq.requestInfo)){
 	((Configuration&)theConfiguration).stopOnError(false);
       }
     }
-  if(!singleuser) {
     if(!c_stopRec.checkNodeFail(signal)){
       jam();
       return;
     }
-  }
-  
     signal->theData[0] = EventReport::NDBStopStarted;
     signal->theData[1] = StopReq::getSystemStop(c_stopRec.stopReq.requestInfo) ? 1 : 0;
     sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 2, JBB);
+  }
+  else
+  {
+    signal->theData[0] = EventReport::SingleUser;
+    signal->theData[1] = 0;
+    sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 2, JBB);
+  }
 
   NodeState newState(NodeState::SL_STOPPING_1, 
 		     StopReq::getSystemStop(c_stopRec.stopReq.requestInfo));
@@ -2129,9 +2138,11 @@ Ndbcntr::StopRecord::checkNodeFail(Signal* signal){
   
   stopReq.senderRef = 0;
 
+  if (cntr.getNodeState().startLevel != NodeState::SL_SINGLEUSER)
+  {
     NodeState newState(NodeState::SL_STARTED); 
-
     cntr.updateNodeState(signal, newState);
+  }
 
   signal->theData[0] = EventReport::NDBStopAborted;
   cntr.sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 1, JBB);
@@ -2227,12 +2238,24 @@ void Ndbcntr::execABORT_ALL_CONF(Signal* signal){
   jamEntry();
   if(c_stopRec.stopReq.singleuser) {
     jam();
+
     NodeState newState(NodeState::SL_SINGLEUSER);    
     newState.setSingleUser(true);
     newState.setSingleUserApi(c_stopRec.stopReq.singleUserApi);
     updateNodeState(signal, newState);    
     c_stopRec.stopInitiatedTime = NdbTick_CurrentMillisecond();
 
+    StopConf * const stopConf = (StopConf *)&signal->theData[0];
+    stopConf->senderData = c_stopRec.stopReq.senderData;
+    stopConf->nodeState  = (Uint32) NodeState::SL_SINGLEUSER;
+    sendSignal(c_stopRec.stopReq.senderRef, GSN_STOP_CONF, signal, StopConf::SignalLength, JBB);
+
+    c_stopRec.stopReq.senderRef = 0; // the command is done
+
+    signal->theData[0] = EventReport::SingleUser;
+    signal->theData[1] = 1;
+    signal->theData[2] = c_stopRec.stopReq.singleUserApi;
+    sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 3, JBB);
   }
   else 
     {
@@ -2250,7 +2273,13 @@ void Ndbcntr::execABORT_ALL_CONF(Signal* signal){
 
 void Ndbcntr::execABORT_ALL_REF(Signal* signal){
   jamEntry();
-  ndbrequire(false);
+  AbortAllRef *abortAllRef = (AbortAllRef *)&signal->theData[0];
+  AbortAllRef::ErrorCode errorCode = (AbortAllRef::ErrorCode) abortAllRef->errorCode;
+
+  StopRef * const stopRef = (StopRef *)&signal->theData[0];
+  stopRef->senderData = c_stopRec.stopReq.senderData;
+  stopRef->errorCode = StopRef::TransactionAbortFailed;
+  sendSignal(c_stopRec.stopReq.senderRef, GSN_STOP_REF, signal, StopRef::SignalLength, JBB);
 }
 
 void

ndb/src/mgmclient/CommandInterpreter.cpp

@@ -1430,9 +1430,8 @@ CommandInterpreter::executeEnterSingleUser(char* parameters)
     ndbout_c("Entering single user mode for node %d failed", nodeId);
     printError();
   } else {
-    ndbout_c("Entering single user mode");
-    ndbout_c("Access will be granted for API node %d only.", nodeId);
-    ndbout_c("Use ALL STATUS to see when single user mode has been entered.");
+    ndbout_c("Single user mode entered");
+    ndbout_c("Access is granted for API node %d only.", nodeId);
   }
 }
 
@@ -1445,7 +1444,7 @@ CommandInterpreter::executeExitSingleUser(char* parameters)
     printError();
   } else {
     ndbout_c("Exiting single user mode in progress.");
-    ndbout_c("Use ALL STATUS to see when single user mode has been exited.");
+    ndbout_c("Use ALL STATUS or SHOW to see when single user mode has been exited.");
   }
 }
 

ndb/src/mgmsrv/MgmtSrvr.hpp

@@ -22,11 +22,11 @@
 #include <NdbCondition.h>
 #include <mgmapi.h>
 
-
+#include <NdbTCP.h>
+#include <ConfigRetriever.hpp>
 #include <Vector.hpp>
 #include <NodeBitmask.hpp>
 #include <signaldata/ManagementServer.hpp>
-#include "SignalQueue.hpp"
 #include <ndb_version.h>
 #include <EventLogger.hpp>
 #include <signaldata/EventSubscribeReq.hpp>
@@ -213,17 +213,6 @@ public:
   // COULD_NOT_ALLOCATE_MEMORY, SEND_OR_RECEIVE_FAILED
 
 
-  typedef void (* StopCallback)(int nodeId, void * anyData, int errorCode);
-
-  typedef void (* VersionCallback)(int nodeId, int version,
-				   void * anyData, int errorCode);
-
-
-  typedef void (* EnterSingleCallback)(int nodeId, void * anyData, 
-				       int errorCode);
-  typedef void (* ExitSingleCallback)(int nodeId, void * anyData, 
-				      int errorCode);
-
   /**
    * Lock configuration
    */
@@ -272,12 +261,12 @@ public:
    *   @param   processId: Id of the DB process to stop
    *   @return  0 if succeeded, otherwise: as stated above, plus:
    */
-  int stopNode(int nodeId, bool abort = false, StopCallback = 0, void *any= 0);
+  int stopNode(int nodeId, bool abort = false);
 
   /**
    *   Stop the system
    */
-  int stop(int * cnt = 0, bool abort = false, StopCallback = 0, void *any = 0);
+  int stop(int * cnt = 0, bool abort = false);
 
   /**
    *   print version info about a node
@@ -285,27 +274,18 @@ public:
    *   @param   processId: Id of the DB process to stop
    *   @return  0 if succeeded, otherwise: as stated above, plus:
    */
-  int versionNode(int nodeId, bool abort = false, 
-		  VersionCallback = 0, void *any= 0);
-
-  /**
-   *   print version info about all node in the system
-   */
-  int version(int * cnt = 0, bool abort = false, 
-	      VersionCallback = 0, void *any = 0);
+  int versionNode(int nodeId, Uint32 &version);
 
   /**
    *   Maintenance on the system
    */
-  int enterSingleUser(int * cnt = 0, Uint32 singleuserNodeId = 0,
-		      EnterSingleCallback = 0, void *any = 0);
+  int enterSingleUser(int * cnt = 0, Uint32 singleuserNodeId = 0);
 
 
   /**
    *   Resume from maintenance on the system
    */
-  int exitSingleUser(int * cnt = 0, bool abort = false, 
-	     ExitSingleCallback = 0, void *any = 0);
+  int exitSingleUser(int * cnt = 0, bool abort = false);
 
   /**
    *   Start DB process.
@@ -319,15 +299,14 @@ public:
    *   @param processId: Id of the DB process to start
    */
   int restartNode(int processId, bool nostart, bool initialStart, 
-		  bool abort = false,
-		  StopCallback = 0, void * anyData = 0);
+		  bool abort = false);
   
   /**
    *   Restart the system
    */
   int restart(bool nostart, bool initialStart, 
 	      bool abort = false,
-	      int * stopCount = 0, StopCallback = 0, void * anyData = 0);
+	      int * stopCount = 0);
   
   struct BackupEvent {
     enum Event {
@@ -518,6 +497,16 @@ private:
   //**************************************************************************
 
   int setEventReportingLevel(int processId, LogLevel::EventCategory, Uint32); 
+  void set_common_stop_req_params(void *stopReq);
+
+  int sendSTOP_REQ(NodeId nodeId,
+		   NodeBitmask &stoppedNodes,
+		   Uint32 singleUserNodeId,
+		   bool abort,
+		   bool stop,
+		   bool restart,
+		   bool nostart,
+		   bool initialStart);
  
   /**
    *   Check if it is possible to send a signal to a (DB) process
@@ -608,60 +597,9 @@ private:
   enum WaitSignalType { 
     NO_WAIT,			// We don't expect to receive any signal
     WAIT_SET_VAR,		// Accept SET_VAR_CONF and SET_VAR_REF
-    WAIT_SUBSCRIBE_CONF,	// Accept event subscription confirmation
-    WAIT_STOP,
-    WAIT_BACKUP_STARTED,
-    WAIT_BACKUP_COMPLETED,
-    WAIT_VERSION,
-    WAIT_NODEFAILURE
+    WAIT_SUBSCRIBE_CONF 	// Accept event subscription confirmation
   };
   
-  /**
-   *   Get an unused signal
-   *   @return  A signal if succeeded, NULL otherwise
-   */
-  NdbApiSignal* getSignal();
-
-  /**
-   *   Add a signal to the list of unused signals
-   *   @param  signal: The signal to add
-   */
-  void releaseSignal(NdbApiSignal* signal);
-
-  /**
-   *   Remove a signal from the list of unused signals and delete
-   *   the memory for it.
-   */
-  void freeSignal();
-  
-  /**
-   *   Send a signal
-   *   @param   processId: Id of the receiver process
-   *   @param   waitState: State denoting a set of signals we accept to receive
-   *   @param   signal: The signal to send
-   *   @return  0 if succeeded, -1 otherwise
-   */
-  int sendSignal(Uint16 processId, WaitSignalType waitState, 
-		 NdbApiSignal* signal, bool force = false);
-  
-  /**
-   *   Send a signal and wait for an answer signal
-   *   @param   processId: Id of the receiver process
-   *   @param   waitState: State denoting a set of signals we accept to receive.
-   *   @param   signal: The signal to send
-   *   @return  0 if succeeded, -1 otherwise (for example failed to send or 
-   *            failed to receive expected signal).
-   */
-  int sendRecSignal(Uint16 processId, WaitSignalType waitState, 
-		    NdbApiSignal* signal, bool force = false,
-		    int waitTime = WAIT_FOR_RESPONSE_TIMEOUT);
-  
-  /**
-   *   Wait for a signal to arrive.
-   *   @return  0 if signal arrived, -1 otherwise
-   */
-  int receiveOptimisedResponse(int waitTime);
-  
   /**
    *   This function is called from "outside" of MgmtSrvr
    *   when a signal is sent to MgmtSrvr.
@@ -708,31 +646,7 @@ private:
 
   class TransporterFacade * theFacade;
 
-  class SignalQueue m_signalRecvQueue;
-
-  struct StopRecord {
-    StopRecord(){ inUse = false; callback = 0; singleUserMode = false;}
-    bool inUse;
-    bool singleUserMode;
-    int sentCount;
-    int reply;
-    int nodeId;
-    void * anyData;
-    StopCallback callback;
-  };
-  StopRecord m_stopRec;
-
-  struct VersionRecord {
-    VersionRecord(){ inUse = false; callback = 0;}
-    bool inUse;
-    Uint32 version[MAX_NODES];
-    VersionCallback callback;
-  };
-  VersionRecord m_versionRec;
-  int  sendVersionReq( int processId);
-
-
-  void handleStopReply(NodeId nodeId, Uint32 errCode);
+  int  sendVersionReq( int processId, Uint32 &version);
   int translateStopRef(Uint32 errCode);
   
   bool _isStopThread;
@@ -753,14 +667,8 @@ private:
   static void *logLevelThread_C(void *);
   void logLevelThreadRun();
   
-  struct NdbThread *m_signalRecvThread;
-  static void *signalRecvThread_C(void *);
-  void signalRecvThreadRun();
-  
   Config *_props;
 
-  int send(class NdbApiSignal* signal, Uint32 node, Uint32 node_type);
-
   ConfigRetriever *m_config_retriever;
 };
 

ndb/src/mgmsrv/MgmtSrvrConfig.cpp

@@ -23,6 +23,8 @@
 #include <ConfigRetriever.hpp>
 #include <ndb_version.h>
 
+#if 0 // code must be rewritten to use SignalSender
+
 void
 MgmtSrvr::handle_MGM_LOCK_CONFIG_REQ(NdbApiSignal *signal) {
   NodeId sender = refToNode(signal->theSendersBlockRef);
@@ -221,6 +223,8 @@ MgmtSrvr::unlockConf(bool commit) {
   return result;
 }
 
+#endif // code must be rewritten to use SignalSender
+
 /**
  * Commit the new configuration
  */

ndb/src/mgmsrv/MgmtSrvrGeneralSignalHandling.cpp

@@ -20,123 +20,3 @@
 // Some kind of reuse should be preferred.
 //******************************************************************************
 
-#include "MgmtSrvr.hpp"
-#include <NdbApiSignal.hpp>
-#include <NdbTick.h>
-
-
-NdbApiSignal*
-MgmtSrvr::getSignal()
-{
-  NdbApiSignal* tSignal;
-  tSignal = theSignalIdleList;
-  if (tSignal != NULL){
-    NdbApiSignal* tSignalNext = tSignal->next();
-    tSignal->next(NULL);
-    theSignalIdleList = tSignalNext;
-    return tSignal;
-  } else
-  {
-    tSignal = new NdbApiSignal(_ownReference);
-    if (tSignal != NULL)
-      tSignal->next(NULL);
-  }
-  return tSignal;
-}
-
-
-void
-MgmtSrvr::releaseSignal(NdbApiSignal* aSignal)
-{
-  aSignal->next(theSignalIdleList);
-  theSignalIdleList = aSignal;
-}
-
-
-void
-MgmtSrvr::freeSignal()
-{
-  NdbApiSignal* tSignal = theSignalIdleList;
-  theSignalIdleList = tSignal->next();
-  delete tSignal;
-}
-
-
-int
-MgmtSrvr::sendSignal(Uint16 aNodeId,
-		     WaitSignalType aWaitState,
-		     NdbApiSignal* aSignal,
-		     bool force)
-{
-  int tReturnCode;
-  theFacade->lock_mutex();
-  if(force){
-    tReturnCode = theFacade->sendSignalUnCond(aSignal, 
-								  aNodeId);
-  } else {
-    tReturnCode = theFacade->sendSignal(aSignal, 
-							    aNodeId);
-  }
-  releaseSignal(aSignal);
-  if (tReturnCode == -1) {
-    theFacade->unlock_mutex();
-    return -1;
-  }
-  theWaitState = aWaitState;
-  theFacade->unlock_mutex();
-  return 0;
-}
-
-
-int
-MgmtSrvr::sendRecSignal(Uint16 aNodeId,
-			WaitSignalType aWaitState,
-			NdbApiSignal* aSignal,
-			bool force,
-			int waitTime)
-{
-  int tReturnCode;
-  theFacade->lock_mutex();
-  if(force){
-    tReturnCode = theFacade->sendSignalUnCond(aSignal, aNodeId);
-  } else {
-    tReturnCode = theFacade->sendSignalUnCond(aSignal, aNodeId);
-  }
-  releaseSignal(aSignal);
-  if (tReturnCode == -1) {
-    theFacade->unlock_mutex();
-    return -1;
-  }
-  theWaitState = aWaitState;
-  theWaitNode = aNodeId;
-  return receiveOptimisedResponse(waitTime);
-}
-
-
-int	
-MgmtSrvr::receiveOptimisedResponse(int waitTime)
-{
-  int tResultCode;
-  theFacade->checkForceSend(_blockNumber);
-  NDB_TICKS maxTime = NdbTick_CurrentMillisecond() + waitTime;
-  
-  while (theWaitState != NO_WAIT && theWaitState != WAIT_NODEFAILURE
-	 && waitTime > 0) {
-    NdbCondition_WaitTimeout(theMgmtWaitForResponseCondPtr, 
-			     theFacade->theMutexPtr,
-			     waitTime);
-    if(theWaitState == NO_WAIT || theWaitState == WAIT_NODEFAILURE)
-      break;
-    waitTime = (maxTime - NdbTick_CurrentMillisecond());
-  }//while
-  
-  if(theWaitState == NO_WAIT) {
-    tResultCode = 0;
-  } else {
-    tResultCode = -1;
-  }
-  theFacade->unlock_mutex();
-  return tResultCode;
-}
-
-

ndb/src/mgmsrv/Services.cpp

@@ -1203,7 +1203,11 @@ MgmApiSession::setLogFilter(Parser_t::Context &ctx,
 void
 MgmApiSession::configLock(Parser_t::Context &,
 			   Properties const &) {
+#if 0 // not implemented
   int ret = m_mgmsrv.lockConf();
+#else
+  int ret = -1;
+#endif
   m_output->println("config lock reply");
   m_output->println("result: %d", ret);
   m_output->println("");
@@ -1214,7 +1218,11 @@ MgmApiSession::configUnlock(Parser_t::Context &,
 			   Properties const &args) {
   Uint32 commit;
   args.get("commit", &commit);
+#if 0 // not implemented
   int ret = m_mgmsrv.unlockConf(commit == 1);
+#else
+  int ret = -1;
+#endif
   m_output->println("config unlock reply");
   m_output->println("result: %d", ret);
   m_output->println("");