开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
NdbRestarter.cpp
资源名称：mysql-4.1.16-win-src.zip　[点击查看]
上传用户：romrleung
上传日期：2022-05-23
资源大小：18897k
文件大小：15k
源码类别：

MySQL数据库

开发平台：

Visual C++

NdbRestarter.cpp：源码内容
  1. /* Copyright (C) 2003 MySQL AB
  3.    This program is free software; you can redistribute it and/or modify
  4.    it under the terms of the GNU General Public License as published by
  5.    the Free Software Foundation; either version 2 of the License, or
  6.    (at your option) any later version.
  8.    This program is distributed in the hope that it will be useful,
  9.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11.    GNU General Public License for more details.
  13.    You should have received a copy of the GNU General Public License
  14.    along with this program; if not, write to the Free Software
  15.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  17. #include <NdbRestarter.hpp>
  18. #include <NdbOut.hpp>
  19. #include <NdbSleep.h>
  20. #include <NdbTick.h>
  21. #include <mgmapi_debug.h>
  22. #include <NDBT_Output.hpp>
  23. #include <random.h>
  24. #include <kernel/ndb_limits.h>
  25. #include <ndb_version.h>
  27. #define MGMERR(h) 
  28.   ndbout << "latest_error="<<ndb_mgm_get_latest_error(h) 
  29.  << ", line="<<ndb_mgm_get_latest_error_line(h) 
  30.  << endl;
  33. NdbRestarter::NdbRestarter(const char* _addr): 
  34.   connected(false),
  35.   handle(NULL),
  36.   m_config(0)
  37. {
  38.   if (_addr == NULL){
  39.     addr.assign("");
  40.   } else {
  41.     addr.assign(_addr);
  42.   }
  43. }
  45. NdbRestarter::~NdbRestarter(){
  46.   disconnect();
  47. }
  49. int NdbRestarter::getDbNodeId(int _i){
  50.   if (!isConnected())
  51.     return -1;
  53.   if (getStatus() != 0)
  54.     return -1;
  56.   for(size_t i = 0; i < ndbNodes.size(); i++){     
  57.     if (i == (unsigned)_i){
  58.       return ndbNodes[i].node_id;
  59.     }
  60.   }
  61.   return -1;
  62. }
  65. int
  66. NdbRestarter::restartOneDbNode(int _nodeId,
  67.        bool inital,
  68.        bool nostart,
  69.        bool abort){
  70.   if (!isConnected())
  71.     return -1;
  73.   int ret = 0;
  74.   
  75.   if ((ret = ndb_mgm_restart2(handle, 1, &_nodeId,
  76.       inital, nostart, abort)) <= 0) {
  77.     /**
  78.      * ndb_mgm_restart2 returned error, one reason could
  79.      * be that the node have not stopped fast enough!
  80.      * Check status of the node to see if it's on the 
  81.      * way down. If that's the case ignore the error
  82.      */ 
  84.     if (getStatus() != 0)
  85.       return -1;
  87.     g_info << "ndb_mgm_restart2 returned with error, checking node state" << endl;
  89.     for(size_t i = 0; i < ndbNodes.size(); i++){
  90.       if(ndbNodes[i].node_id == _nodeId){
  91. g_info <<_nodeId<<": status="<<ndbNodes[i].node_status<<endl;
  92. /* Node found check state */
  93. switch(ndbNodes[i].node_status){
  94. case NDB_MGM_NODE_STATUS_RESTARTING:
  95. case NDB_MGM_NODE_STATUS_SHUTTING_DOWN:
  96.   return 0;
  97. default:
  98.   break;
  99. }
  100.       }
  101.     }
  102.     
  103.     MGMERR(handle);
  104.     g_err  << "Could not stop node with id = "<< _nodeId << endl;
  105.     return -1;
  106.   }
  108.   return 0;
  109. }
  111. int
  112. NdbRestarter::getMasterNodeId(){
  113.   if (!isConnected())
  114.     return -1;
  115.   
  116.   if (getStatus() != 0)
  117.     return -1;
  118.   
  119.   int min = 0;
  120.   int node = -1;
  121.   for(size_t i = 0; i < ndbNodes.size(); i++){
  122.     if(min == 0 || ndbNodes[i].dynamic_id < min){
  123.       min = ndbNodes[i].dynamic_id;
  124.       node = ndbNodes[i].node_id;
  125.     }
  126.   }
  128.   return node;
  129. }
  131. int
  132. NdbRestarter::getRandomNotMasterNodeId(int rand){
  133.   int master = getMasterNodeId();
  134.   if(master == -1)
  135.     return -1;
  137.   Uint32 counter = 0;
  138.   rand = rand % ndbNodes.size();
  139.   while(counter++ < ndbNodes.size() && ndbNodes[rand].node_id == master)
  140.     rand = (rand + 1) % ndbNodes.size();
  141.   
  142.   if(ndbNodes[rand].node_id != master)
  143.     return ndbNodes[rand].node_id;
  144.   return -1;
  145. }
  147. int
  148. NdbRestarter::getRandomNodeOtherNodeGroup(int nodeId, int rand){
  149.   if (!isConnected())
  150.     return -1;
  151.   
  152.   if (getStatus() != 0)
  153.     return -1;
  154.   
  155.   int node_group = -1;
  156.   for(size_t i = 0; i < ndbNodes.size(); i++){
  157.     if(ndbNodes[i].node_id == nodeId){
  158.       node_group = ndbNodes[i].node_group;
  159.       break;
  160.     }
  161.   }
  162.   if(node_group == -1){
  163.     return -1;
  164.   }
  166.   Uint32 counter = 0;
  167.   rand = rand % ndbNodes.size();
  168.   while(counter++ < ndbNodes.size() && ndbNodes[rand].node_group == node_group)
  169.     rand = (rand + 1) % ndbNodes.size();
  170.   
  171.   if(ndbNodes[rand].node_group != node_group)
  172.     return ndbNodes[rand].node_id;
  174.   return -1;
  175. }
  177. int 
  178. NdbRestarter::waitClusterStarted(unsigned int _timeout){
  179.   return waitClusterState(NDB_MGM_NODE_STATUS_STARTED, _timeout);
  180. }
  182. int 
  183. NdbRestarter::waitClusterStartPhase(int _startphase, unsigned int _timeout){
  184.   return waitClusterState(NDB_MGM_NODE_STATUS_STARTING, _timeout, _startphase);
  185. }
  187. int 
  188. NdbRestarter::waitClusterSingleUser(unsigned int _timeout){
  189.   return waitClusterState(NDB_MGM_NODE_STATUS_SINGLEUSER, _timeout);
  190. }
  192. int 
  193. NdbRestarter::waitClusterNoStart(unsigned int _timeout){
  194.   return waitClusterState(NDB_MGM_NODE_STATUS_NOT_STARTED, _timeout);
  195. }
  197. int 
  198. NdbRestarter::waitClusterState(ndb_mgm_node_status _status,
  199.        unsigned int _timeout,
  200.        int _startphase){
  202.   int nodes[MAX_NDB_NODES];
  203.   int numNodes = 0;
  205.   if (getStatus() != 0)
  206.     return -1;
  207.   
  208.   // Collect all nodes into nodes
  209.   for (size_t i = 0; i < ndbNodes.size(); i++){
  210.     nodes[i] = ndbNodes[i].node_id;
  211.     numNodes++;
  212.   }
  214.   return waitNodesState(nodes, numNodes, _status, _timeout, _startphase);
  215. }
  216.  
  218. int 
  219. NdbRestarter::waitNodesState(int * _nodes, int _num_nodes,
  220.      ndb_mgm_node_status _status,
  221.      unsigned int _timeout,
  222.      int _startphase){
  223.   
  224.   if (!isConnected()){
  225.     g_err << "!isConnected"<<endl;
  226.     return -1;
  227.   }
  229.   unsigned int attempts = 0;
  230.   unsigned int resetAttempts = 0;
  231.   const unsigned int MAX_RESET_ATTEMPTS = 10;
  232.   bool allInState = false;    
  233.   while (allInState == false){
  234.     if (_timeout > 0 && attempts > _timeout){
  235.       /**
  236.        * Timeout has expired waiting for the nodes to enter
  237.        * the state we want
  238.        */
  239.       bool waitMore = false;
  240.       /** 
  241.        * Make special check if we are waiting for 
  242.        * cluster to become started
  243.        */
  244.       if(_status == NDB_MGM_NODE_STATUS_STARTED){
  245. waitMore = true;
  246. /**
  247.  * First check if any node is not starting
  248.  * then it's no idea to wait anymore
  249.  */
  250. for (size_t n = 0; n < ndbNodes.size(); n++){
  251.   if (ndbNodes[n].node_status != NDB_MGM_NODE_STATUS_STARTED &&
  252.       ndbNodes[n].node_status != NDB_MGM_NODE_STATUS_STARTING)
  253.     waitMore = false;
  255. }
  256.       } 
  258.       if (!waitMore || resetAttempts > MAX_RESET_ATTEMPTS){
  259. g_err << "waitNodeState("
  260.       << ndb_mgm_get_node_status_string(_status)
  261.       <<", "<<_startphase<<")"
  262.       << " timeout after " << attempts <<" attemps" << endl;
  263. return -1;
  264.       } 
  266.       g_err << "waitNodeState("
  267.     << ndb_mgm_get_node_status_string(_status)
  268.     <<", "<<_startphase<<")"
  269.     << " resetting number of attempts "
  270.     << resetAttempts << endl;
  271.       attempts = 0;
  272.       resetAttempts++;
  273.       
  274.     }
  276.     allInState = true;
  277.     if (getStatus() != 0){
  278.       g_err << "getStatus != 0" << endl;
  279.       return -1;
  280.     }
  282.     // ndbout << "waitNodeState; _num_nodes = " << _num_nodes << endl;
  283.     // for (int i = 0; i < _num_nodes; i++)
  284.     //   ndbout << " node["<<i<<"] =" <<_nodes[i] << endl;
  286.     for (int i = 0; i < _num_nodes; i++){
  287.       ndb_mgm_node_state* ndbNode = NULL;
  288.       for (size_t n = 0; n < ndbNodes.size(); n++){
  289. if (ndbNodes[n].node_id == _nodes[i])
  290.   ndbNode = &ndbNodes[n];
  291.       }
  293.       if(ndbNode == NULL){
  294. allInState = false;
  295. continue;
  296.       }
  298.       g_info << "State node " << ndbNode->node_id << " "
  299.      << ndb_mgm_get_node_status_string(ndbNode->node_status)<< endl;
  301.       assert(ndbNode != NULL);
  303.       if(_status == NDB_MGM_NODE_STATUS_STARTING && 
  304.  ((ndbNode->node_status == NDB_MGM_NODE_STATUS_STARTING && 
  305.    ndbNode->start_phase >= _startphase) ||
  306.   (ndbNode->node_status == NDB_MGM_NODE_STATUS_STARTED)))
  307. continue;
  309.       if (_status == NDB_MGM_NODE_STATUS_STARTING){
  310. g_info << "status = "  
  311.        << ndb_mgm_get_node_status_string(ndbNode->node_status)
  312.        <<", start_phase="<<ndbNode->start_phase<<endl;
  313. if (ndbNode->node_status !=  _status) {
  314.   if (ndbNode->node_status < _status)
  315.     allInState = false;
  316.   else 
  317.     g_info << "node_status(" << ndbNode->node_status
  318.    <<") != _status("<<_status<<")"<<endl;
  319. } else if (ndbNode->start_phase < _startphase)
  320.   allInState = false;
  321.       } else {
  322. if (ndbNode->node_status !=  _status) 
  323.   allInState = false;
  324.       }
  325.     }
  326.     g_info << "Waiting for cluster enter state" 
  327.     << ndb_mgm_get_node_status_string(_status)<< endl;
  328.     NdbSleep_SecSleep(1);
  329.     attempts++;
  330.   }
  331.   return 0;
  332. }
  334. int NdbRestarter::waitNodesStarted(int * _nodes, int _num_nodes,
  335.      unsigned int _timeout){
  336.   return waitNodesState(_nodes, _num_nodes, 
  337.   NDB_MGM_NODE_STATUS_STARTED, _timeout);  
  338. }
  340. int NdbRestarter::waitNodesStartPhase(int * _nodes, int _num_nodes, 
  341. int _startphase, unsigned int _timeout){
  342.   return waitNodesState(_nodes, _num_nodes, 
  343.   NDB_MGM_NODE_STATUS_STARTING, _timeout,
  344.   _startphase);  
  345. }
  347. int NdbRestarter::waitNodesNoStart(int * _nodes, int _num_nodes,
  348.      unsigned int _timeout){
  349.   return waitNodesState(_nodes, _num_nodes, 
  350.   NDB_MGM_NODE_STATUS_NOT_STARTED, _timeout);  
  351. }
  353. bool 
  354. NdbRestarter::isConnected(){
  355.   if (connected == true)
  356.     return true;
  357.   return connect() == 0;
  358. }
  360. int 
  361. NdbRestarter::connect(){
  362.   disconnect();
  363.   handle = ndb_mgm_create_handle();   
  364.   if (handle == NULL){
  365.     g_err << "handle == NULL" << endl;
  366.     return -1;
  367.   }
  368.   g_info << "Connecting to mgmsrv at " << addr.c_str() << endl;
  369.   if (ndb_mgm_set_connectstring(handle,addr.c_str()))
  370.   {
  371.     MGMERR(handle);
  372.     g_err  << "Connection to " << addr.c_str() << " failed" << endl;
  373.     return -1;
  374.   }
  376.   if (ndb_mgm_connect(handle, 0, 0, 0) == -1)
  377.   {
  378.     MGMERR(handle);
  379.     g_err  << "Connection to " << addr.c_str() << " failed" << endl;
  380.     return -1;
  381.   }
  383.   connected = true;
  384.   return 0;
  385. }
  387. void 
  388. NdbRestarter::disconnect(){
  389.   if (handle != NULL){
  390.     ndb_mgm_disconnect(handle);
  391.     ndb_mgm_destroy_handle(&handle);
  392.   }
  393.   connected = false;
  394. }
  396. int 
  397. NdbRestarter::getStatus(){
  398.   int retries = 0;
  399.   struct ndb_mgm_cluster_state * status;
  400.   struct ndb_mgm_node_state * node;
  401.   
  402.   ndbNodes.clear();
  403.   mgmNodes.clear();
  404.   apiNodes.clear();
  406.   if (!isConnected())
  407.     return -1;
  408.   
  409.   while(retries < 10){
  410.     status = ndb_mgm_get_status(handle);
  411.     if (status == NULL){
  412.       ndbout << "status==NULL, retries="<<retries<<endl;
  413.       MGMERR(handle);
  414.       retries++;
  415.       continue;
  416.     }
  417.     for (int i = 0; i < status->no_of_nodes; i++){
  418.       node = &status->node_states[i];      
  419.       switch(node->node_type){
  420.       case NDB_MGM_NODE_TYPE_NDB:
  421. ndbNodes.push_back(*node);
  422. break;
  423.       case NDB_MGM_NODE_TYPE_MGM:
  424. mgmNodes.push_back(*node);
  425. break;
  426.       case NDB_MGM_NODE_TYPE_API:
  427. apiNodes.push_back(*node);
  428. break;
  429.       default:
  430. if(node->node_status == NDB_MGM_NODE_STATUS_UNKNOWN ||
  431.    node->node_status == NDB_MGM_NODE_STATUS_NO_CONTACT){
  432.   retries++;
  433.   ndbNodes.clear();
  434.   mgmNodes.clear();
  435.   apiNodes.clear();
  436.   free(status); 
  437.   status = NULL;
  438.   i = status->no_of_nodes;
  440.   ndbout << "kalle"<< endl;
  441.   break;
  442. }
  443. abort();
  444. break;
  445.       }
  446.     }
  447.     if(status == 0){
  448.       ndbout << "status == 0" << endl;
  449.       continue;
  450.     }
  451.     free(status);
  452.     return 0;
  453.   }
  454.    
  455.   g_err  << "getStatus failed" << endl;
  456.   return -1;
  457. }
  460. int NdbRestarter::getNumDbNodes(){
  461.   if (!isConnected())
  462.     return -1;
  464.   if (getStatus() != 0)
  465.     return -1;
  467.   return ndbNodes.size();
  468. }
  470. int NdbRestarter::restartAll(bool initial,
  471.      bool nostart,
  472.      bool abort){
  473.   
  474.   if (!isConnected())
  475.     return -1;
  477.   if (ndb_mgm_restart2(handle, 0, NULL, initial, 1, abort) == -1) {
  478.     MGMERR(handle);
  479.     g_err  << "Could not restart(stop) all nodes " << endl;
  480.     // return -1; Continue anyway - Magnus
  481.   }
  482.   
  483.   if (waitClusterNoStart(60) != 0){
  484.     g_err << "Cluster didnt enter STATUS_NOT_STARTED within 60s" << endl;
  485.     return -1;
  486.   }
  487.   
  488.   if(nostart){
  489.     g_debug << "restartAll: nostart == true" << endl;
  490.     return 0;
  491.   }
  493.   if (ndb_mgm_start(handle, 0, NULL) == -1) {
  494.     MGMERR(handle);
  495.     g_err  << "Could not restart(start) all nodes " << endl;
  496.     return -1;
  497.   }
  498.   
  499.   return 0;
  500. }
  502. int NdbRestarter::startAll(){
  503.   if (!isConnected())
  504.     return -1;
  506.   if (ndb_mgm_start(handle, 0, NULL) == -1) {
  507.     MGMERR(handle);
  508.     g_err  << "Could not start all nodes " << endl;
  509.     return -1;
  510.   }
  511.   
  512.   return 0;
  513.   
  514. }
  516. int NdbRestarter::startNodes(int * nodes, int num_nodes){
  517.   if (!isConnected())
  518.     return -1;
  519.   
  520.   if (ndb_mgm_start(handle, num_nodes, nodes) != num_nodes) {
  521.     MGMERR(handle);
  522.     g_err  << "Could not start all nodes " << endl;
  523.     return -1;
  524.   }
  525.   
  526.   return 0;
  527. }
  529. int NdbRestarter::insertErrorInNode(int _nodeId, int _error){
  530.   if (!isConnected())
  531.     return -1;
  533.   ndb_mgm_reply reply;
  534.   reply.return_code = 0;
  536.   if (ndb_mgm_insert_error(handle, _nodeId, _error, &reply) == -1){
  537.     MGMERR(handle);
  538.     g_err << "Could not insert error in node with id = "<< _nodeId << endl;
  539.   }
  540.   if(reply.return_code != 0){
  541.     g_err << "Error: " << reply.message << endl;
  542.   }
  543.   return 0;
  544. }
  546. int NdbRestarter::insertErrorInAllNodes(int _error){
  547.   if (!isConnected())
  548.     return -1;
  550.   if (getStatus() != 0)
  551.     return -1;
  553.   int result = 0;
  554.  
  555.   for(size_t i = 0; i < ndbNodes.size(); i++){     
  556.     g_debug << "inserting error in node " << ndbNodes[i].node_id << endl;
  557.     if (insertErrorInNode(ndbNodes[i].node_id, _error) == -1)
  558.       result = -1;
  559.   }
  560.   return result;
  562. }
  566. int NdbRestarter::dumpStateOneNode(int _nodeId, int * _args, int _num_args){
  567.  if (!isConnected())
  568.     return -1;
  570.   ndb_mgm_reply reply;
  571.   reply.return_code = 0;
  573.   if (ndb_mgm_dump_state(handle, _nodeId, _args, _num_args, &reply) == -1){
  574.     MGMERR(handle);
  575.     g_err << "Could not dump state in node with id = "<< _nodeId << endl;
  576.   }
  578.   if(reply.return_code != 0){
  579.     g_err << "Error: " << reply.message << endl;
  580.   }
  581.   return reply.return_code;  
  582. }
  584. int NdbRestarter::dumpStateAllNodes(int * _args, int _num_args){
  585.  if (!isConnected())
  586.     return -1;
  588.  if (getStatus() != 0)
  589.    return -1;
  591.  int result = 0;
  592.  
  593.  for(size_t i = 0; i < ndbNodes.size(); i++){     
  594.    g_debug << "dumping state in node " << ndbNodes[i].node_id << endl;
  595.    if (dumpStateOneNode(ndbNodes[i].node_id, _args, _num_args) == -1)
  596.      result = -1;
  597.  }
  598.  return result;
  600. }
  603. int NdbRestarter::enterSingleUserMode(int _nodeId){
  604.   if (!isConnected())
  605.     return -1;
  607.   ndb_mgm_reply reply;
  608.   reply.return_code = 0;
  610.   if (ndb_mgm_enter_single_user(handle, _nodeId, &reply) == -1){
  611.     MGMERR(handle);
  612.     g_err << "Could not enter single user mode api node = "<< _nodeId << endl;
  613.   }
  614.   
  615.   if(reply.return_code != 0){
  616.     g_err << "Error: " << reply.message << endl;
  617.   }
  618.   
  619.   return reply.return_code;  
  620. }
  623. int NdbRestarter::exitSingleUserMode(){
  624.   if (!isConnected())
  625.     return -1;
  627.   ndb_mgm_reply reply;
  628.   reply.return_code = 0;
  630.   if (ndb_mgm_exit_single_user(handle, &reply) == -1){
  631.     MGMERR(handle);
  632.     g_err << "Could not exit single user mode " << endl;
  633.   }
  635.   if(reply.return_code != 0){
  636.     g_err << "Error: " << reply.message << endl;
  637.   }
  638.   return reply.return_code;  
  639. }
  641. ndb_mgm_configuration*
  642. NdbRestarter::getConfig(){
  643.   if(m_config) return m_config;
  645.   if (!isConnected())
  646.     return 0;
  647.   m_config = ndb_mgm_get_configuration(handle, 0);
  648.   return m_config;
  649. }
  651. template class Vector<ndb_mgm_node_state>;