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

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

MySQL数据库

开发平台：

Visual C++

MgmtSrvr.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 <ndb_global.h>
  18. #include <my_pthread.h>
  20. #include "MgmtSrvr.hpp"
  21. #include "MgmtErrorReporter.hpp"
  22. #include <ConfigRetriever.hpp>
  24. #include <NdbOut.hpp>
  25. #include <NdbApiSignal.hpp>
  26. #include <kernel_types.h>
  27. #include <RefConvert.hpp>
  28. #include <BlockNumbers.h>
  29. #include <GlobalSignalNumbers.h>
  30. #include <signaldata/TestOrd.hpp>
  31. #include <signaldata/TamperOrd.hpp>
  32. #include <signaldata/StartOrd.hpp>
  33. #include <signaldata/ApiVersion.hpp>
  34. #include <signaldata/ResumeReq.hpp>
  35. #include <signaldata/SetLogLevelOrd.hpp>
  36. #include <signaldata/EventSubscribeReq.hpp>
  37. #include <signaldata/EventReport.hpp>
  38. #include <signaldata/DumpStateOrd.hpp>
  39. #include <signaldata/BackupSignalData.hpp>
  40. #include <signaldata/GrepImpl.hpp>
  41. #include <signaldata/ManagementServer.hpp>
  42. #include <signaldata/NFCompleteRep.hpp>
  43. #include <signaldata/NodeFailRep.hpp>
  44. #include <NdbSleep.h>
  45. #include <EventLogger.hpp>
  46. #include <DebuggerNames.hpp>
  47. #include <ndb_version.h>
  49. #include <SocketServer.hpp>
  50. #include <NdbConfig.h>
  52. #include <NdbAutoPtr.hpp>
  54. #include <ndberror.h>
  56. #include <mgmapi.h>
  57. #include <mgmapi_configuration.hpp>
  58. #include <mgmapi_config_parameters.h>
  59. #include <m_string.h>
  61. #include <SignalSender.hpp>
  63. //#define MGM_SRV_DEBUG
  64. #ifdef MGM_SRV_DEBUG
  65. #define DEBUG(x) do ndbout << x << endl; while(0)
  66. #else
  67. #define DEBUG(x)
  68. #endif
  70. #define INIT_SIGNAL_SENDER(ss,nodeId) 
  71.   SignalSender ss(theFacade); 
  72.   ss.lock(); /* lock will be released on exit */ 
  73.   {
  74.     int result = okToSendTo(nodeId, true);
  75.     if (result != 0) {
  76.       return result;
  77.     }
  78.   }
  80. extern int global_flag_send_heartbeat_now;
  81. extern int g_no_nodeid_checks;
  82. extern my_bool opt_core;
  84. static void require(bool v)
  85. {
  86.   if(!v)
  87.   {
  88.     if (opt_core)
  89.       abort();
  90.     else
  91.       exit(-1);
  92.   }
  93. }
  95. void *
  96. MgmtSrvr::logLevelThread_C(void* m)
  97. {
  98.   MgmtSrvr *mgm = (MgmtSrvr*)m;
  99.   mgm->logLevelThreadRun();
  100.   return 0;
  101. }
  103. extern EventLogger g_eventLogger;
  105. static NdbOut&
  106. operator<<(NdbOut& out, const LogLevel & ll)
  107. {
  108.   out << "[LogLevel: ";
  109.   for(size_t i = 0; i<LogLevel::LOGLEVEL_CATEGORIES; i++)
  110.     out << ll.getLogLevel((LogLevel::EventCategory)i) << " ";
  111.   out << "]";
  112.   return out;
  113. }
  115. void
  116. MgmtSrvr::logLevelThreadRun() 
  117. {
  118.   while (!_isStopThread) {
  119.     /**
  120.      * Handle started nodes
  121.      */
  122.     EventSubscribeReq req;
  123.     req = m_event_listner[0].m_logLevel;
  124.     req.blockRef = _ownReference;
  126.     SetLogLevelOrd ord;
  127.     
  128.     m_started_nodes.lock();
  129.     while(m_started_nodes.size() > 0){
  130.       Uint32 node = m_started_nodes[0];
  131.       m_started_nodes.erase(0, false);
  132.       m_started_nodes.unlock();
  134.       setEventReportingLevelImpl(node, req);
  135.       
  136.       ord = m_nodeLogLevel[node];
  137.       setNodeLogLevelImpl(node, ord);
  138.       
  139.       m_started_nodes.lock();
  140.     }  
  141.     m_started_nodes.unlock();
  142.     
  143.     m_log_level_requests.lock();
  144.     while(m_log_level_requests.size() > 0){
  145.       req = m_log_level_requests[0];
  146.       m_log_level_requests.erase(0, false);
  147.       m_log_level_requests.unlock();
  148.       
  149.       LogLevel tmp;
  150.       tmp = req;
  151.       
  152.       if(req.blockRef == 0){
  153. req.blockRef = _ownReference;
  154. setEventReportingLevelImpl(0, req);
  155.       } else {
  156. ord = req;
  157. setNodeLogLevelImpl(req.blockRef, ord);
  158.       }
  159.       m_log_level_requests.lock();
  160.     }      
  161.     m_log_level_requests.unlock();
  162.     NdbSleep_MilliSleep(_logLevelThreadSleep);  
  163.   }
  164. }
  166. void
  167. MgmtSrvr::startEventLog() 
  168. {
  169.   g_eventLogger.setCategory("MgmSrvr");
  171.   ndb_mgm_configuration_iterator * iter = ndb_mgm_create_configuration_iterator
  172.     ((ndb_mgm_configuration*)_config->m_configValues, CFG_SECTION_NODE);
  173.   if(iter == 0)
  174.     return ;
  175.   
  176.   if(ndb_mgm_find(iter, CFG_NODE_ID, _ownNodeId) != 0){
  177.     ndb_mgm_destroy_iterator(iter);
  178.     return ;
  179.   }
  180.   
  181.   const char * tmp;
  182.   BaseString logdest;
  183.   char *clusterLog= NdbConfig_ClusterLogFileName(_ownNodeId);
  184.   NdbAutoPtr<char> tmp_aptr(clusterLog);
  186.   if(ndb_mgm_get_string_parameter(iter, CFG_LOG_DESTINATION, &tmp) == 0){
  187.     logdest.assign(tmp);
  188.   }
  189.   ndb_mgm_destroy_iterator(iter);
  190.   
  191.   if(logdest.length() == 0 || logdest == "") {
  192.     logdest.assfmt("FILE:filename=%s,maxsize=1000000,maxfiles=6", 
  193.    clusterLog);
  194.   }
  195.   if(!g_eventLogger.addHandler(logdest)) {
  196.     ndbout << "Warning: could not add log destination ""
  197.    << logdest.c_str() << """ << endl;
  198.   }
  199. }
  201. void 
  202. MgmtSrvr::stopEventLog() 
  203. {
  204.   // Nothing yet
  205. }
  207. class ErrorItem 
  208. {
  209. public:
  210.   int _errorCode;
  211.   const char * _errorText;
  212. };
  214. bool
  215. MgmtSrvr::setEventLogFilter(int severity, int enable)
  216. {
  217.   Logger::LoggerLevel level = (Logger::LoggerLevel)severity;
  218.   if (enable > 0) {
  219.     g_eventLogger.enable(level);
  220.   } else if (enable == 0) {
  221.     g_eventLogger.disable(level);
  222.   } else if (g_eventLogger.isEnable(level)) {
  223.     g_eventLogger.disable(level);
  224.   } else {
  225.     g_eventLogger.enable(level);
  226.   }
  227.   return g_eventLogger.isEnable(level);
  228. }
  230. bool 
  231. MgmtSrvr::isEventLogFilterEnabled(int severity) 
  232. {
  233.   return g_eventLogger.isEnable((Logger::LoggerLevel)severity);
  234. }
  236. static ErrorItem errorTable[] = 
  237. {
  238.   {MgmtSrvr::NO_CONTACT_WITH_PROCESS, "No contact with the process (dead ?)."},
  239.   {MgmtSrvr::PROCESS_NOT_CONFIGURED, "The process is not configured."},
  240.   {MgmtSrvr::WRONG_PROCESS_TYPE, 
  241.    "The process has wrong type. Expected a DB process."},
  242.   {MgmtSrvr::COULD_NOT_ALLOCATE_MEMORY, "Could not allocate memory."},
  243.   {MgmtSrvr::SEND_OR_RECEIVE_FAILED, "Send to process or receive failed."},
  244.   {MgmtSrvr::INVALID_LEVEL, "Invalid level. Should be between 1 and 30."},
  245.   {MgmtSrvr::INVALID_ERROR_NUMBER, "Invalid error number. Should be >= 0."},
  246.   {MgmtSrvr::INVALID_TRACE_NUMBER, "Invalid trace number."},
  247.   {MgmtSrvr::NOT_IMPLEMENTED, "Not implemented."},
  248.   {MgmtSrvr::INVALID_BLOCK_NAME, "Invalid block name"},
  250.   {MgmtSrvr::CONFIG_PARAM_NOT_EXIST, 
  251.    "The configuration parameter does not exist for the process type."},
  252.   {MgmtSrvr::CONFIG_PARAM_NOT_UPDATEABLE, 
  253.    "The configuration parameter is not possible to update."},
  254.   {MgmtSrvr::VALUE_WRONG_FORMAT_INT_EXPECTED, 
  255.    "Incorrect value. Expected integer."},
  256.   {MgmtSrvr::VALUE_TOO_LOW, "Value is too low."},
  257.   {MgmtSrvr::VALUE_TOO_HIGH, "Value is too high."},
  258.   {MgmtSrvr::VALUE_WRONG_FORMAT_BOOL_EXPECTED, 
  259.    "Incorrect value. Expected TRUE or FALSE."},
  261.   {MgmtSrvr::CONFIG_FILE_OPEN_WRITE_ERROR, 
  262.    "Could not open configuration file for writing."},
  263.   {MgmtSrvr::CONFIG_FILE_OPEN_READ_ERROR, 
  264.    "Could not open configuration file for reading."},
  265.   {MgmtSrvr::CONFIG_FILE_WRITE_ERROR, 
  266.    "Write error when writing configuration file."},
  267.   {MgmtSrvr::CONFIG_FILE_READ_ERROR, 
  268.    "Read error when reading configuration file."},
  269.   {MgmtSrvr::CONFIG_FILE_CLOSE_ERROR, "Could not close configuration file."},
  271.   {MgmtSrvr::CONFIG_CHANGE_REFUSED_BY_RECEIVER, 
  272.    "The change was refused by the receiving process."},
  273.   {MgmtSrvr::COULD_NOT_SYNC_CONFIG_CHANGE_AGAINST_PHYSICAL_MEDIUM, 
  274.    "The change could not be synced against physical medium."},
  275.   {MgmtSrvr::CONFIG_FILE_CHECKSUM_ERROR, 
  276.    "The config file is corrupt. Checksum error."},
  277.   {MgmtSrvr::NOT_POSSIBLE_TO_SEND_CONFIG_UPDATE_TO_PROCESS_TYPE, 
  278.    "It is not possible to send an update of a configuration variable "
  279.    "to this kind of process."},
  280.   {5026, "Node shutdown in progress" },
  281.   {5027, "System shutdown in progress" },
  282.   {5028, "Node shutdown would cause system crash" },
  283.   {5029, "Only one shutdown at a time is possible via mgm server" },
  284.   {5060, "Operation not allowed in single user mode." }, 
  285.   {5061, "DB is not in single user mode." },
  286.   {5062, "The specified node is not an API node." },
  287.   {5063, 
  288.    "Cannot enter single user mode. DB nodes in inconsistent startlevel."},
  289.   {MgmtSrvr::NO_CONTACT_WITH_DB_NODES, "No contact with database nodes" }
  290. };
  292. int MgmtSrvr::translateStopRef(Uint32 errCode)
  293. {
  294.   switch(errCode){
  295.   case StopRef::NodeShutdownInProgress:
  296.     return 5026;
  297.     break;
  298.   case StopRef::SystemShutdownInProgress:
  299.     return 5027;
  300.     break;
  301.   case StopRef::NodeShutdownWouldCauseSystemCrash:
  302.     return 5028;
  303.     break;
  304.   }
  305.   return 4999;
  306. }
  308. static int noOfErrorCodes = sizeof(errorTable) / sizeof(ErrorItem);
  310. int 
  311. MgmtSrvr::getNodeCount(enum ndb_mgm_node_type type) const 
  312. {
  313.   int count = 0;
  314.   NodeId nodeId = 0;
  316.   while (getNextNodeId(&nodeId, type)) {
  317.     count++;
  318.   }
  319.   return count;
  320. }
  322. int 
  323. MgmtSrvr::getPort() const {
  324.   const Properties *mgmProps;
  325.   
  326.   ndb_mgm_configuration_iterator * iter = 
  327.     ndb_mgm_create_configuration_iterator(_config->m_configValues, 
  328.   CFG_SECTION_NODE);
  329.   if(iter == 0)
  330.     return 0;
  332.   if(ndb_mgm_find(iter, CFG_NODE_ID, getOwnNodeId()) != 0){
  333.     ndbout << "Could not retrieve configuration for Node " 
  334.    << getOwnNodeId() << " in config file." << endl 
  335.    << "Have you set correct NodeId for this node?" << endl;
  336.     ndb_mgm_destroy_iterator(iter);
  337.     return 0;
  338.   }
  340.   unsigned type;
  341.   if(ndb_mgm_get_int_parameter(iter, CFG_TYPE_OF_SECTION, &type) != 0 ||
  342.      type != NODE_TYPE_MGM){
  343.     ndbout << "Local node id " << getOwnNodeId()
  344.    << " is not defined as management server" << endl
  345.    << "Have you set correct NodeId for this node?" << endl;
  346.     ndb_mgm_destroy_iterator(iter);
  347.     return 0;
  348.   }
  349.   
  350.   Uint32 port = 0;
  351.   if(ndb_mgm_get_int_parameter(iter, CFG_MGM_PORT, &port) != 0){
  352.     ndbout << "Could not find PortNumber in the configuration file." << endl;
  353.     ndb_mgm_destroy_iterator(iter);
  354.     return 0;
  355.   }
  357.   ndb_mgm_destroy_iterator(iter);
  358.   
  359.   return port;
  360. }
  362. /* Constructor */
  363. int MgmtSrvr::init()
  364. {
  365.   if ( _ownNodeId > 0)
  366.     return 0;
  367.   return -1;
  368. }
  370. MgmtSrvr::MgmtSrvr(SocketServer *socket_server,
  371.    const char *config_filename,
  372.    const char *connect_string) :
  373.   _blockNumber(1), // Hard coded block number since it makes it easy to send
  374.                    // signals to other management servers.
  375.   m_socket_server(socket_server),
  376.   _ownReference(0),
  377.   theSignalIdleList(NULL),
  378.   theWaitState(WAIT_SUBSCRIBE_CONF),
  379.   m_event_listner(this)
  380. {
  381.     
  382.   DBUG_ENTER("MgmtSrvr::MgmtSrvr");
  384.   _ownNodeId= 0;
  386.   _config     = NULL;
  388.   _isStopThread        = false;
  389.   _logLevelThread      = NULL;
  390.   _logLevelThreadSleep = 500;
  392.   theFacade = 0;
  394.   m_newConfig = NULL;
  395.   if (config_filename)
  396.     m_configFilename.assign(config_filename);
  397.   else
  398.     m_configFilename.assign("config.ini");
  400.   m_nextConfigGenerationNumber = 0;
  402.   m_config_retriever= new ConfigRetriever(connect_string,
  403.   NDB_VERSION, NDB_MGM_NODE_TYPE_MGM);
  404.   // if connect_string explicitly given or
  405.   // no config filename is given then
  406.   // first try to allocate nodeid from another management server
  407.   if ((connect_string || config_filename == NULL) &&
  408.       (m_config_retriever->do_connect(0,0,0) == 0))
  409.   {
  410.     int tmp_nodeid= 0;
  411.     tmp_nodeid= m_config_retriever->allocNodeId(0 /*retry*/,0 /*delay*/);
  412.     if (tmp_nodeid == 0)
  413.     {
  414.       ndbout_c(m_config_retriever->getErrorString());
  415.       require(false);
  416.     }
  417.     // read config from other managent server
  418.     _config= fetchConfig();
  419.     if (_config == 0)
  420.     {
  421.       ndbout << m_config_retriever->getErrorString() << endl;
  422.       require(false);
  423.     }
  424.     _ownNodeId= tmp_nodeid;
  425.   }
  427.   if (_ownNodeId == 0)
  428.   {
  429.     // read config locally
  430.     _config= readConfig();
  431.     if (_config == 0) {
  432.       ndbout << "Unable to read config file" << endl;
  433.       require(false);
  434.     }
  435.   }
  437.   theMgmtWaitForResponseCondPtr = NdbCondition_Create();
  439.   m_configMutex = NdbMutex_Create();
  441.   /**
  442.    * Fill the nodeTypes array
  443.    */
  444.   for(Uint32 i = 0; i<MAX_NODES; i++) {
  445.     nodeTypes[i] = (enum ndb_mgm_node_type)-1;
  446.     m_connect_address[i].s_addr= 0;
  447.   }
  449.   {
  450.     ndb_mgm_configuration_iterator
  451.       *iter = ndb_mgm_create_configuration_iterator(_config->m_configValues,
  452.     CFG_SECTION_NODE);
  453.     for(ndb_mgm_first(iter); ndb_mgm_valid(iter); ndb_mgm_next(iter)){
  454.       unsigned type, id;
  455.       if(ndb_mgm_get_int_parameter(iter, CFG_TYPE_OF_SECTION, &type) != 0)
  456. continue;
  457.       
  458.       if(ndb_mgm_get_int_parameter(iter, CFG_NODE_ID, &id) != 0)
  459. continue;
  460.       
  461.       MGM_REQUIRE(id < MAX_NODES);
  462.       
  463.       switch(type){
  464.       case NODE_TYPE_DB:
  465. nodeTypes[id] = NDB_MGM_NODE_TYPE_NDB;
  466. break;
  467.       case NODE_TYPE_API:
  468. nodeTypes[id] = NDB_MGM_NODE_TYPE_API;
  469. break;
  470.       case NODE_TYPE_MGM:
  471. nodeTypes[id] = NDB_MGM_NODE_TYPE_MGM;
  472. break;
  473.       case NODE_TYPE_REP:
  474. nodeTypes[id] = NDB_MGM_NODE_TYPE_REP;
  475. break;
  476.       case NODE_TYPE_EXT_REP:
  477.       default:
  478. break;
  479.       }
  480.     }
  481.     ndb_mgm_destroy_iterator(iter);
  482.   }
  484.   _props = NULL;
  485.   BaseString error_string;
  487.   if ((m_node_id_mutex = NdbMutex_Create()) == 0)
  488.   {
  489.     ndbout << "mutex creation failed line = " << __LINE__ << endl;
  490.     require(false);
  491.   }
  493.   if (_ownNodeId == 0) // we did not get node id from other server
  494.   {
  495.     NodeId tmp= m_config_retriever->get_configuration_nodeid();
  497.     if (!alloc_node_id(&tmp, NDB_MGM_NODE_TYPE_MGM,
  498.        0, 0, error_string)){
  499.       ndbout << "Unable to obtain requested nodeid: "
  500.      << error_string.c_str() << endl;
  501.       require(false);
  502.     }
  503.     _ownNodeId = tmp;
  504.   }
  506.   {
  507.     DBUG_PRINT("info", ("verifyConfig"));
  508.     if (!m_config_retriever->verifyConfig(_config->m_configValues,
  509.   _ownNodeId))
  510.     {
  511.       ndbout << m_config_retriever->getErrorString() << endl;
  512.       require(false);
  513.     }
  514.   }
  516.   // Setup clusterlog as client[0] in m_event_listner
  517.   {
  518.     Ndb_mgmd_event_service::Event_listener se;
  519.     se.m_socket = NDB_INVALID_SOCKET;
  520.     for(size_t t = 0; t<LogLevel::LOGLEVEL_CATEGORIES; t++){
  521.       se.m_logLevel.setLogLevel((LogLevel::EventCategory)t, 7);
  522.     }
  523.     se.m_logLevel.setLogLevel(LogLevel::llError, 15);
  524.     se.m_logLevel.setLogLevel(LogLevel::llConnection, 8);
  525.     se.m_logLevel.setLogLevel(LogLevel::llBackup, 15);
  526.     m_event_listner.m_clients.push_back(se);
  527.     m_event_listner.m_logLevel = se.m_logLevel;
  528.   }
  529.   
  530.   DBUG_VOID_RETURN;
  531. }
  534. //****************************************************************************
  535. //****************************************************************************
  536. bool 
  537. MgmtSrvr::check_start() 
  538. {
  539.   if (_config == 0) {
  540.     DEBUG("MgmtSrvr.cpp: _config is NULL.");
  541.     return false;
  542.   }
  544.   return true;
  545. }
  547. bool 
  548. MgmtSrvr::start(BaseString &error_string)
  549. {
  550.   DBUG_ENTER("MgmtSrvr::start");
  551.   if (_props == NULL) {
  552.     if (!check_start()) {
  553.       error_string.append("MgmtSrvr.cpp: check_start() failed.");
  554.       DBUG_RETURN(false);
  555.     }
  556.   }
  557.   theFacade= TransporterFacade::theFacadeInstance= new TransporterFacade();
  558.   
  559.   if(theFacade == 0) {
  560.     DEBUG("MgmtSrvr.cpp: theFacade is NULL.");
  561.     error_string.append("MgmtSrvr.cpp: theFacade is NULL.");
  562.     DBUG_RETURN(false);
  563.   }  
  564.   if ( theFacade->start_instance
  565.        (_ownNodeId, (ndb_mgm_configuration*)_config->m_configValues) < 0) {
  566.     DEBUG("MgmtSrvr.cpp: TransporterFacade::start_instance < 0.");
  567.     DBUG_RETURN(false);
  568.   }
  570.   MGM_REQUIRE(_blockNumber == 1);
  572.   // Register ourself at TransporterFacade to be able to receive signals
  573.   // and to be notified when a database process has died.
  574.   _blockNumber = theFacade->open(this,
  575.  signalReceivedNotification,
  576.  nodeStatusNotification);
  577.   
  578.   if(_blockNumber == -1){
  579.     DEBUG("MgmtSrvr.cpp: _blockNumber is -1.");
  580.     error_string.append("MgmtSrvr.cpp: _blockNumber is -1.");
  581.     theFacade->stop_instance();
  582.     theFacade = 0;
  583.     DBUG_RETURN(false);
  584.   }
  585.   
  586.   _ownReference = numberToRef(_blockNumber, _ownNodeId);
  587.   
  588.   startEventLog();
  589.   // Set the initial confirmation count for subscribe requests confirm
  590.   // from NDB nodes in the cluster.
  591.   //
  592.   // Loglevel thread
  593.   _logLevelThread = NdbThread_Create(logLevelThread_C,
  594.      (void**)this,
  595.      32768,
  596.      "MgmtSrvr_Loglevel",
  597.      NDB_THREAD_PRIO_LOW);
  599.   DBUG_RETURN(true);
  600. }
  603. //****************************************************************************
  604. //****************************************************************************
  605. MgmtSrvr::~MgmtSrvr() 
  606. {
  607.   if(theFacade != 0){
  608.     theFacade->stop_instance();
  609.     delete theFacade;
  610.     theFacade = 0;
  611.   }
  613.   stopEventLog();
  615.   NdbMutex_Destroy(m_node_id_mutex);
  616.   NdbCondition_Destroy(theMgmtWaitForResponseCondPtr);
  617.   NdbMutex_Destroy(m_configMutex);
  619.   if(m_newConfig != NULL)
  620.     free(m_newConfig);
  622.   if(_config != NULL)
  623.     delete _config;
  625.   // End set log level thread
  626.   void* res = 0;
  627.   _isStopThread = true;
  629.   if (_logLevelThread != NULL) {
  630.     NdbThread_WaitFor(_logLevelThread, &res);
  631.     NdbThread_Destroy(&_logLevelThread);
  632.   }
  634.   if (m_config_retriever)
  635.     delete m_config_retriever;
  636. }
  638. //****************************************************************************
  639. //****************************************************************************
  641. int MgmtSrvr::okToSendTo(NodeId nodeId, bool unCond) 
  642. {
  643.   if(nodeId == 0)
  644.     return 0;
  646.   if (getNodeType(nodeId) != NDB_MGM_NODE_TYPE_NDB)
  647.     return WRONG_PROCESS_TYPE;
  648.   
  649.   // Check if we have contact with it
  650.   if(unCond){
  651.     if(theFacade->theClusterMgr->getNodeInfo(nodeId).connected)
  652.       return 0;
  653.     return NO_CONTACT_WITH_PROCESS;
  654.   }
  655.   if (theFacade->get_node_alive(nodeId) == 0) {
  656.     return NO_CONTACT_WITH_PROCESS;
  657.   } else {
  658.     return 0;
  659.   }
  660. }
  662. void report_unknown_signal(SimpleSignal *signal)
  663. {
  664.   g_eventLogger.error("Unknown signal received. SignalNumber: "
  665.       "%i from (%d, %x)",
  666.       signal->readSignalNumber(),
  667.       refToNode(signal->header.theSendersBlockRef),
  668.       refToBlock(signal->header.theSendersBlockRef));
  669. }
  671. /*****************************************************************************
  672.  * Starting and stopping database nodes
  673.  ****************************************************************************/
  675. int 
  676. MgmtSrvr::start(int nodeId)
  677. {
  678.   INIT_SIGNAL_SENDER(ss,nodeId);
  679.   
  680.   SimpleSignal ssig;
  681.   StartOrd* const startOrd = CAST_PTR(StartOrd, ssig.getDataPtrSend());
  682.   ssig.set(ss,TestOrd::TraceAPI, CMVMI, GSN_START_ORD, StartOrd::SignalLength);
  683.   startOrd->restartInfo = 0;
  684.   
  685.   return ss.sendSignal(nodeId, &ssig) == SEND_OK ? 0 : SEND_OR_RECEIVE_FAILED;
  686. }
  688. /*****************************************************************************
  689.  * Version handling
  690.  *****************************************************************************/
  692. int 
  693. MgmtSrvr::versionNode(int nodeId, Uint32 &version, const char **address)
  694. {
  695.   version= 0;
  696.   if (getOwnNodeId() == nodeId)
  697.   {
  698.     /**
  699.      * If we're inquiring about our own node id,
  700.      * We know what version we are (version implies connected for mgm)
  701.      * but would like to find out from elsewhere what address they're using
  702.      * to connect to us. This means that secondary mgm servers
  703.      * can list ip addresses for mgm servers.
  704.      *
  705.      * If we don't get an address (i.e. no db nodes),
  706.      * we get the address from the configuration.
  707.      */
  708.     sendVersionReq(nodeId, version, address);
  709.     version= NDB_VERSION;
  710.     if(!*address)
  711.     {
  712.       ndb_mgm_configuration_iterator
  713. iter(*_config->m_configValues, CFG_SECTION_NODE);
  714.       unsigned tmp= 0;
  715.       for(iter.first();iter.valid();iter.next())
  716.       {
  717. if(iter.get(CFG_NODE_ID, &tmp)) require(false);
  718. if((unsigned)nodeId!=tmp)
  719.   continue;
  720. if(iter.get(CFG_NODE_HOST, address)) require(false);
  721. break;
  722.       }
  723.     }
  724.   }
  725.   else if (getNodeType(nodeId) == NDB_MGM_NODE_TYPE_NDB)
  726.   {
  727.     ClusterMgr::Node node= theFacade->theClusterMgr->getNodeInfo(nodeId);
  728.     if(node.connected)
  729.       version= node.m_info.m_version;
  730.     *address= get_connect_address(nodeId);
  731.   }
  732.   else if (getNodeType(nodeId) == NDB_MGM_NODE_TYPE_API ||
  733.    getNodeType(nodeId) == NDB_MGM_NODE_TYPE_MGM)
  734.   {
  735.     return sendVersionReq(nodeId, version, address);
  736.   }
  738.   return 0;
  739. }
  741. int 
  742. MgmtSrvr::sendVersionReq(int v_nodeId, Uint32 &version, const char **address)
  743. {
  744.   SignalSender ss(theFacade);
  745.   ss.lock();
  747.   SimpleSignal ssig;
  748.   ApiVersionReq* req = CAST_PTR(ApiVersionReq, ssig.getDataPtrSend());
  749.   req->senderRef = ss.getOwnRef();
  750.   req->nodeId = v_nodeId;
  751.   ssig.set(ss, TestOrd::TraceAPI, QMGR, GSN_API_VERSION_REQ, 
  752.    ApiVersionReq::SignalLength);
  754.   int do_send = 1;
  755.   NodeId nodeId;
  757.   while (1)
  758.   {
  759.     if (do_send)
  760.     {
  761.       bool next;
  762.       nodeId = 0;
  764.       while((next = getNextNodeId(&nodeId, NDB_MGM_NODE_TYPE_NDB)) == true &&
  765.     okToSendTo(nodeId, true) != 0);
  767.       const ClusterMgr::Node &node=
  768. theFacade->theClusterMgr->getNodeInfo(nodeId);
  769.       if(next && node.m_state.startLevel != NodeState::SL_STARTED)
  770.       {
  771. NodeId tmp=nodeId;
  772. while((next = getNextNodeId(&nodeId, NDB_MGM_NODE_TYPE_NDB)) == true &&
  773.       okToSendTo(nodeId, true) != 0);
  774. if(!next)
  775.   nodeId= tmp;
  776.       }
  778.       if(!next) return NO_CONTACT_WITH_DB_NODES;
  780.       if (ss.sendSignal(nodeId, &ssig) != SEND_OK) {
  781. return SEND_OR_RECEIVE_FAILED;
  782.       }
  783.       do_send = 0;
  784.     }
  786.     SimpleSignal *signal = ss.waitFor();
  788.     int gsn = signal->readSignalNumber();
  789.     switch (gsn) {
  790.     case GSN_API_VERSION_CONF: {
  791.       const ApiVersionConf * const conf = 
  792. CAST_CONSTPTR(ApiVersionConf, signal->getDataPtr());
  793.       assert(conf->nodeId == v_nodeId);
  794.       version = conf->version;
  795.       struct in_addr in;
  796.       in.s_addr= conf->inet_addr;
  797.       *address= inet_ntoa(in);
  798.       return 0;
  799.     }
  800.     case GSN_NF_COMPLETEREP:{
  801.       const NFCompleteRep * const rep =
  802. CAST_CONSTPTR(NFCompleteRep, signal->getDataPtr());
  803.       if (rep->failedNodeId == nodeId)
  804. do_send = 1; // retry with other node
  805.       continue;
  806.     }
  807.     case GSN_NODE_FAILREP:{
  808.       const NodeFailRep * const rep =
  809. CAST_CONSTPTR(NodeFailRep, signal->getDataPtr());
  810.       if (NodeBitmask::get(rep->theNodes,nodeId))
  811. do_send = 1; // retry with other node
  812.       continue;
  813.     }
  814.     default:
  815.       report_unknown_signal(signal);
  816.       return SEND_OR_RECEIVE_FAILED;
  817.     }
  818.     break;
  819.   } // while(1)
  821.   return 0;
  822. }
  824. /*
  825.  * Common method for handeling all STOP_REQ signalling that
  826.  * is used by Stopping, Restarting and Single user commands
  827.  */
  829. int MgmtSrvr::sendSTOP_REQ(NodeId nodeId,
  830.    NodeBitmask &stoppedNodes,
  831.    Uint32 singleUserNodeId,
  832.    bool abort,
  833.    bool stop,
  834.    bool restart,
  835.    bool nostart,
  836.    bool initialStart)
  837. {
  838.   stoppedNodes.clear();
  840.   SignalSender ss(theFacade);
  841.   ss.lock(); // lock will be released on exit
  843.   SimpleSignal ssig;
  844.   StopReq* const stopReq = CAST_PTR(StopReq, ssig.getDataPtrSend());
  845.   ssig.set(ss, TestOrd::TraceAPI, NDBCNTR, GSN_STOP_REQ, StopReq::SignalLength);
  847.   stopReq->requestInfo = 0;
  848.   stopReq->apiTimeout = 5000;
  849.   stopReq->transactionTimeout = 1000;
  850.   stopReq->readOperationTimeout = 1000;
  851.   stopReq->operationTimeout = 1000;
  852.   stopReq->senderData = 12;
  853.   stopReq->senderRef = ss.getOwnRef();
  854.   if (singleUserNodeId)
  855.   {
  856.     stopReq->singleuser = 1;
  857.     stopReq->singleUserApi = singleUserNodeId;
  858.     StopReq::setSystemStop(stopReq->requestInfo, false);
  859.     StopReq::setPerformRestart(stopReq->requestInfo, false);
  860.     StopReq::setStopAbort(stopReq->requestInfo, false);
  861.   }
  862.   else
  863.   {
  864.     stopReq->singleuser = 0;
  865.     StopReq::setSystemStop(stopReq->requestInfo, stop);
  866.     StopReq::setPerformRestart(stopReq->requestInfo, restart);
  867.     StopReq::setStopAbort(stopReq->requestInfo, abort);
  868.     StopReq::setNoStart(stopReq->requestInfo, nostart);
  869.     StopReq::setInitialStart(stopReq->requestInfo, initialStart);
  870.   }
  872.   // send the signals
  873.   NodeBitmask nodes;
  874.   if (nodeId)
  875.   {
  876.     {
  877.       int r;
  878.       if((r = okToSendTo(nodeId, true)) != 0)
  879. return r;
  880.     }
  881.     {
  882.       if (ss.sendSignal(nodeId, &ssig) != SEND_OK)
  883. return SEND_OR_RECEIVE_FAILED;
  884.     }
  885.     nodes.set(nodeId);
  886.   }
  887.   else
  888.     while(getNextNodeId(&nodeId, NDB_MGM_NODE_TYPE_NDB))
  889.     {
  890.       if(okToSendTo(nodeId, true) == 0)
  891.       {
  892. SendStatus result = ss.sendSignal(nodeId, &ssig);
  893. if (result == SEND_OK)
  894.   nodes.set(nodeId);
  895.       }
  896.     }
  898.   // now wait for the replies
  899.   int error = 0;
  900.   while (!nodes.isclear())
  901.   {
  902.     SimpleSignal *signal = ss.waitFor();
  903.     int gsn = signal->readSignalNumber();
  904.     switch (gsn) {
  905.     case GSN_STOP_REF:{
  906.       const StopRef * const ref = CAST_CONSTPTR(StopRef, signal->getDataPtr());
  907.       const NodeId nodeId = refToNode(signal->header.theSendersBlockRef);
  908. #ifdef VM_TRACE
  909.       ndbout_c("Node %d refused stop", nodeId);
  910. #endif
  911.       assert(nodes.get(nodeId));
  912.       nodes.clear(nodeId);
  913.       error = translateStopRef(ref->errorCode);
  914.       break;
  915.     }
  916.     case GSN_STOP_CONF:{
  917.       const StopConf * const ref = CAST_CONSTPTR(StopConf, signal->getDataPtr());
  918.       const NodeId nodeId = refToNode(signal->header.theSendersBlockRef);
  919. #ifdef VM_TRACE
  920.       ndbout_c("Node %d single user mode", nodeId);
  921. #endif
  922.       assert(nodes.get(nodeId));
  923.       assert(singleUserNodeId != 0);
  924.       nodes.clear(nodeId);
  925.       stoppedNodes.set(nodeId);
  926.       break;
  927.     }
  928.     case GSN_NF_COMPLETEREP:{
  929.       const NFCompleteRep * const rep =
  930. CAST_CONSTPTR(NFCompleteRep, signal->getDataPtr());
  931. #ifdef VM_TRACE
  932.       ndbout_c("Node %d fail completed", rep->failedNodeId);
  933. #endif
  934.       break;
  935.     }
  936.     case GSN_NODE_FAILREP:{
  937.       const NodeFailRep * const rep =
  938. CAST_CONSTPTR(NodeFailRep, signal->getDataPtr());
  939.       NodeBitmask failedNodes;
  940.       failedNodes.assign(NodeBitmask::Size, rep->theNodes);
  941. #ifdef VM_TRACE
  942.       {
  943. ndbout << "Failed nodes:";
  944. for (unsigned i = 0; i < 32*NodeBitmask::Size; i++)
  945.   if(failedNodes.get(i))
  946.     ndbout << " " << i;
  947. ndbout << endl;
  948.       }
  949. #endif
  950.       failedNodes.bitAND(nodes);
  951.       if (!failedNodes.isclear())
  952.       {
  953. nodes.bitANDC(failedNodes); // clear the failed nodes
  954. if (singleUserNodeId == 0)
  955.   stoppedNodes.bitOR(failedNodes);
  956.       }
  957.       break;
  958.     }
  959.     default:
  960.       report_unknown_signal(signal);
  961. #ifdef VM_TRACE
  962.       ndbout_c("Unknown signal %d", gsn);
  963. #endif
  964.       return SEND_OR_RECEIVE_FAILED;
  965.     }
  966.   }
  967.   return error;
  968. }
  970. /*
  971.  * Stop one node
  972.  */
  974. int MgmtSrvr::stopNode(int nodeId, bool abort)
  975. {
  976.   NodeBitmask nodes;
  977.   return sendSTOP_REQ(nodeId,
  978.       nodes,
  979.       0,
  980.       abort,
  981.       false,
  982.       false,
  983.       false,
  984.       false);
  985. }
  987. /*
  988.  * Perform system shutdown
  989.  */
  991. int MgmtSrvr::stop(int * stopCount, bool abort)
  992. {
  993.   NodeBitmask nodes;
  994.   int ret = sendSTOP_REQ(0,
  995.  nodes,
  996.  0,
  997.  abort,
  998.  true,
  999.  false,
  1000.  false,
  1001.  false);
  1002.   if (stopCount)
  1003.     *stopCount = nodes.count();
  1004.   return ret;
  1005. }
  1007. /*
  1008.  * Enter single user mode on all live nodes
  1009.  */
  1011. int MgmtSrvr::enterSingleUser(int * stopCount, Uint32 singleUserNodeId)
  1012. {
  1013.   if (getNodeType(singleUserNodeId) != NDB_MGM_NODE_TYPE_API)
  1014.     return 5062;
  1015.   NodeId nodeId = 0;
  1016.   ClusterMgr::Node node;
  1017.   while(getNextNodeId(&nodeId, NDB_MGM_NODE_TYPE_NDB))
  1018.   {
  1019.     node = theFacade->theClusterMgr->getNodeInfo(nodeId);
  1020.     if((node.m_state.startLevel != NodeState::SL_STARTED) && 
  1021.        (node.m_state.startLevel != NodeState::SL_NOTHING))
  1022.       return 5063;
  1023.   }
  1024.   NodeBitmask nodes;
  1025.   int ret = sendSTOP_REQ(0,
  1026.  nodes,
  1027.  singleUserNodeId,
  1028.  false,
  1029.  false,
  1030.  false,
  1031.  false,
  1032.  false);
  1033.   if (stopCount)
  1034.     *stopCount = nodes.count();
  1035.   return ret;
  1036. }
  1038. /*
  1039.  * Perform node restart
  1040.  */
  1042. int MgmtSrvr::restartNode(int nodeId, bool nostart, bool initialStart, 
  1043.   bool abort)
  1044. {
  1045.   NodeBitmask nodes;
  1046.   return sendSTOP_REQ(nodeId,
  1047.       nodes,
  1048.       0,
  1049.       abort,
  1050.       false,
  1051.       true,
  1052.       nostart,
  1053.       initialStart);
  1054. }
  1056. /*
  1057.  * Perform system restart
  1058.  */
  1060. int MgmtSrvr::restart(bool nostart, bool initialStart, 
  1061.       bool abort, int * stopCount )
  1062. {
  1063.   NodeBitmask nodes;
  1064.   int ret = sendSTOP_REQ(0,
  1065.  nodes,
  1066.  0,
  1067.  abort,
  1068.  true,
  1069.  true,
  1070.  true,
  1071.  initialStart);
  1073.   if (ret)
  1074.     return ret;
  1076.   if (stopCount)
  1077.     *stopCount = nodes.count();
  1079. #ifdef VM_TRACE
  1080.     ndbout_c("Stopped %d nodes", nodes.count());
  1081. #endif
  1082.   /**
  1083.    * Here all nodes were correctly stopped,
  1084.    * so we wait for all nodes to be contactable
  1085.    */
  1086.   int waitTime = 12000;
  1087.   NodeId nodeId = 0;
  1088.   NDB_TICKS maxTime = NdbTick_CurrentMillisecond() + waitTime;
  1090.   ndbout_c(" %d", nodes.get(1));
  1091.   ndbout_c(" %d", nodes.get(2));
  1093.   while(getNextNodeId(&nodeId, NDB_MGM_NODE_TYPE_NDB)) {
  1094.     if (!nodes.get(nodeId))
  1095.       continue;
  1096.     enum ndb_mgm_node_status s;
  1097.     s = NDB_MGM_NODE_STATUS_NO_CONTACT;
  1098. #ifdef VM_TRACE
  1099.     ndbout_c("Waiting for %d not started", nodeId);
  1100. #endif
  1101.     while (s != NDB_MGM_NODE_STATUS_NOT_STARTED && waitTime > 0) {
  1102.       Uint32 startPhase = 0, version = 0, dynamicId = 0, nodeGroup = 0;
  1103.       Uint32 connectCount = 0;
  1104.       bool system;
  1105.       const char *address;
  1106.       status(nodeId, &s, &version, &startPhase, 
  1107.      &system, &dynamicId, &nodeGroup, &connectCount, &address);
  1108.       NdbSleep_MilliSleep(100);  
  1109.       waitTime = (maxTime - NdbTick_CurrentMillisecond());
  1110.     }
  1111.   }
  1112.   
  1113.   if(nostart)
  1114.     return 0;
  1115.   
  1116.   /**
  1117.    * Now we start all database nodes (i.e. we make them non-idle)
  1118.    * We ignore the result we get from the start command.
  1119.    */
  1120.   nodeId = 0;
  1121.   while(getNextNodeId(&nodeId, NDB_MGM_NODE_TYPE_NDB)) {
  1122.     if (!nodes.get(nodeId))
  1123.       continue;
  1124.     int result;
  1125.     result = start(nodeId);
  1126.     DEBUG("Starting node " << nodeId << " with result " << result);
  1127.     /**
  1128.      * Errors from this call are deliberately ignored.
  1129.      * Maybe the user only wanted to restart a subset of the nodes.
  1130.      * It is also easy for the user to check which nodes have 
  1131.      * started and which nodes have not.
  1132.      */
  1133.   }
  1134.   
  1135.   return 0;
  1136. }
  1138. int
  1139. MgmtSrvr::exitSingleUser(int * stopCount, bool abort)
  1140. {
  1141.   NodeId nodeId = 0;
  1142.   int count = 0;
  1144.   SignalSender ss(theFacade);
  1145.   ss.lock(); // lock will be released on exit
  1147.   SimpleSignal ssig;
  1148.   ResumeReq* const resumeReq = 
  1149.     CAST_PTR(ResumeReq, ssig.getDataPtrSend());
  1150.   ssig.set(ss,TestOrd::TraceAPI, NDBCNTR, GSN_RESUME_REQ, 
  1151.    ResumeReq::SignalLength);
  1152.   resumeReq->senderData = 12;
  1153.   resumeReq->senderRef = ss.getOwnRef();
  1155.   while(getNextNodeId(&nodeId, NDB_MGM_NODE_TYPE_NDB)){
  1156.     if(okToSendTo(nodeId, true) == 0){
  1157.       SendStatus result = ss.sendSignal(nodeId, &ssig);
  1158.       if (result == SEND_OK)
  1159. count++;
  1160.     }
  1161.   }
  1163.   if(stopCount != 0)
  1164.     * stopCount = count;
  1166.   return 0;
  1167. }
  1169. /*****************************************************************************
  1170.  * Status
  1171.  ****************************************************************************/
  1173. #include <ClusterMgr.hpp>
  1175. int 
  1176. MgmtSrvr::status(int nodeId, 
  1177.                  ndb_mgm_node_status * _status, 
  1178.  Uint32 * version,
  1179.  Uint32 * _phase, 
  1180.  bool * _system,
  1181.  Uint32 * dynamic,
  1182.  Uint32 * nodegroup,
  1183.  Uint32 * connectCount,
  1184.  const char **address)
  1185. {
  1186.   if (getNodeType(nodeId) == NDB_MGM_NODE_TYPE_API ||
  1187.       getNodeType(nodeId) == NDB_MGM_NODE_TYPE_MGM) {
  1188.     versionNode(nodeId, *version, address);
  1189.   } else {
  1190.     *address= get_connect_address(nodeId);
  1191.   }
  1193.   const ClusterMgr::Node node = 
  1194.     theFacade->theClusterMgr->getNodeInfo(nodeId);
  1196.   if(!node.connected){
  1197.     * _status = NDB_MGM_NODE_STATUS_NO_CONTACT;
  1198.     return 0;
  1199.   }
  1200.   
  1201.   if (getNodeType(nodeId) == NDB_MGM_NODE_TYPE_NDB) {
  1202.     * version = node.m_info.m_version;
  1203.   }
  1205.   * dynamic = node.m_state.dynamicId;
  1206.   * nodegroup = node.m_state.nodeGroup;
  1207.   * connectCount = node.m_info.m_connectCount;
  1208.   
  1209.   switch(node.m_state.startLevel){
  1210.   case NodeState::SL_CMVMI:
  1211.     * _status = NDB_MGM_NODE_STATUS_NOT_STARTED;
  1212.     * _phase = 0;
  1213.     return 0;
  1214.     break;
  1215.   case NodeState::SL_STARTING:
  1216.     * _status     = NDB_MGM_NODE_STATUS_STARTING;
  1217.     * _phase = node.m_state.starting.startPhase;
  1218.     return 0;
  1219.     break;
  1220.   case NodeState::SL_STARTED:
  1221.     * _status = NDB_MGM_NODE_STATUS_STARTED;
  1222.     * _phase = 0;
  1223.     return 0;
  1224.     break;
  1225.   case NodeState::SL_STOPPING_1:
  1226.     * _status = NDB_MGM_NODE_STATUS_SHUTTING_DOWN;
  1227.     * _phase = 1;
  1228.     * _system = node.m_state.stopping.systemShutdown != 0;
  1229.     return 0;
  1230.     break;
  1231.   case NodeState::SL_STOPPING_2:
  1232.     * _status = NDB_MGM_NODE_STATUS_SHUTTING_DOWN;
  1233.     * _phase = 2;
  1234.     * _system = node.m_state.stopping.systemShutdown != 0;
  1235.     return 0;
  1236.     break;
  1237.   case NodeState::SL_STOPPING_3:
  1238.     * _status = NDB_MGM_NODE_STATUS_SHUTTING_DOWN;
  1239.     * _phase = 3;
  1240.     * _system = node.m_state.stopping.systemShutdown != 0;
  1241.     return 0;
  1242.     break;
  1243.   case NodeState::SL_STOPPING_4:
  1244.     * _status = NDB_MGM_NODE_STATUS_SHUTTING_DOWN;
  1245.     * _phase = 4;
  1246.     * _system = node.m_state.stopping.systemShutdown != 0;
  1247.     return 0;
  1248.     break;
  1249.   case NodeState::SL_SINGLEUSER:
  1250.     * _status = NDB_MGM_NODE_STATUS_SINGLEUSER;
  1251.     * _phase  = 0;
  1252.     return 0;
  1253.     break;
  1254.   default:
  1255.     * _status = NDB_MGM_NODE_STATUS_UNKNOWN;
  1256.     * _phase = 0;
  1257.     return 0;
  1258.   }
  1259.   
  1260.   return -1;
  1261. }
  1263. int 
  1264. MgmtSrvr::setEventReportingLevelImpl(int nodeId, 
  1265.      const EventSubscribeReq& ll)
  1266. {
  1267.   INIT_SIGNAL_SENDER(ss,nodeId);
  1269.   SimpleSignal ssig;
  1270.   EventSubscribeReq * dst = 
  1271.     CAST_PTR(EventSubscribeReq, ssig.getDataPtrSend());
  1272.   ssig.set(ss,TestOrd::TraceAPI, CMVMI, GSN_EVENT_SUBSCRIBE_REQ,
  1273.    EventSubscribeReq::SignalLength);
  1274.   *dst = ll;
  1276.   send(ss,ssig,nodeId,NODE_TYPE_DB);
  1278. #if 0
  1279.   while (1)
  1280.   {
  1281.     SimpleSignal *signal = ss.waitFor();
  1282.     int gsn = signal->readSignalNumber();
  1283.     switch (gsn) { 
  1284.     case GSN_EVENT_SUBSCRIBE_CONF:{
  1285.       break;
  1286.     }
  1287.     case GSN_EVENT_SUBSCRIBE_REF:{
  1288.       return SEND_OR_RECEIVE_FAILED;
  1289.     }
  1290.     case GSN_NF_COMPLETEREP:{
  1291.       const NFCompleteRep * const rep =
  1292. CAST_CONSTPTR(NFCompleteRep, signal->getDataPtr());
  1293.       if (rep->failedNodeId == nodeId)
  1294. return SEND_OR_RECEIVE_FAILED;
  1295.       break;
  1296.     }
  1297.     case GSN_NODE_FAILREP:{
  1298.       const NodeFailRep * const rep =
  1299. CAST_CONSTPTR(NodeFailRep, signal->getDataPtr());
  1300.       if (NodeBitmask::get(rep->theNodes,nodeId))
  1301. return SEND_OR_RECEIVE_FAILED;
  1302.       break;
  1303.     }
  1304.     default:
  1305.       report_unknown_signal(signal);
  1306.       return SEND_OR_RECEIVE_FAILED;
  1307.     }
  1309.   }
  1310. #endif
  1311.   return 0;
  1312. }
  1314. //****************************************************************************
  1315. //****************************************************************************
  1316. int 
  1317. MgmtSrvr::setNodeLogLevelImpl(int nodeId, const SetLogLevelOrd & ll)
  1318. {
  1319.   INIT_SIGNAL_SENDER(ss,nodeId);
  1321.   SimpleSignal ssig;
  1322.   ssig.set(ss,TestOrd::TraceAPI, CMVMI, GSN_SET_LOGLEVELORD,
  1323.    SetLogLevelOrd::SignalLength);
  1324.   SetLogLevelOrd* const dst = CAST_PTR(SetLogLevelOrd, ssig.getDataPtrSend());
  1325.   *dst = ll;
  1326.   
  1327.   return ss.sendSignal(nodeId, &ssig) == SEND_OK ? 0 : SEND_OR_RECEIVE_FAILED;
  1328. }
  1330. int
  1331. MgmtSrvr::send(SignalSender &ss, SimpleSignal &ssig, Uint32 node, Uint32 node_type){
  1332.   Uint32 max = (node == 0) ? MAX_NODES : node + 1;
  1333.   
  1334.   for(; node < max; node++){
  1335.     while(nodeTypes[node] != (int)node_type && node < max) node++;
  1336.     if(nodeTypes[node] != (int)node_type)
  1337.       break;
  1338.     ss.sendSignal(node, &ssig);
  1339.   }
  1340.   return 0;
  1341. }
  1343. //****************************************************************************
  1344. //****************************************************************************
  1346. int 
  1347. MgmtSrvr::insertError(int nodeId, int errorNo) 
  1348. {
  1349.   if (errorNo < 0) {
  1350.     return INVALID_ERROR_NUMBER;
  1351.   }
  1353.   INIT_SIGNAL_SENDER(ss,nodeId);
  1354.   
  1355.   SimpleSignal ssig;
  1356.   ssig.set(ss,TestOrd::TraceAPI, CMVMI, GSN_TAMPER_ORD, 
  1357.    TamperOrd::SignalLength);
  1358.   TamperOrd* const tamperOrd = CAST_PTR(TamperOrd, ssig.getDataPtrSend());
  1359.   tamperOrd->errorNo = errorNo;
  1361.   return ss.sendSignal(nodeId, &ssig) == SEND_OK ? 0 : SEND_OR_RECEIVE_FAILED;
  1362. }
  1366. //****************************************************************************
  1367. //****************************************************************************
  1369. int 
  1370. MgmtSrvr::setTraceNo(int nodeId, int traceNo)
  1371. {
  1372.   if (traceNo < 0) {
  1373.     return INVALID_TRACE_NUMBER;
  1374.   }
  1376.   INIT_SIGNAL_SENDER(ss,nodeId);
  1378.   SimpleSignal ssig;
  1379.   ssig.set(ss,TestOrd::TraceAPI, CMVMI, GSN_TEST_ORD, TestOrd::SignalLength);
  1380.   TestOrd* const testOrd = CAST_PTR(TestOrd, ssig.getDataPtrSend());
  1381.   testOrd->clear();
  1382.   // Assume TRACE command causes toggling. Not really defined... ? TODO
  1383.   testOrd->setTraceCommand(TestOrd::Toggle, 
  1384.    (TestOrd::TraceSpecification)traceNo);
  1386.   return ss.sendSignal(nodeId, &ssig) == SEND_OK ? 0 : SEND_OR_RECEIVE_FAILED;
  1387. }
  1389. //****************************************************************************
  1390. //****************************************************************************
  1392. int 
  1393. MgmtSrvr::getBlockNumber(const BaseString &blockName) 
  1394. {
  1395.   short bno = getBlockNo(blockName.c_str());
  1396.   if(bno != 0)
  1397.     return bno;
  1398.   return -1;
  1399. }
  1401. //****************************************************************************
  1402. //****************************************************************************
  1404. int 
  1405. MgmtSrvr::setSignalLoggingMode(int nodeId, LogMode mode, 
  1406.        const Vector<BaseString>& blocks)
  1407. {
  1408.   INIT_SIGNAL_SENDER(ss,nodeId);
  1410.   // Convert from MgmtSrvr format...
  1412.   TestOrd::Command command;
  1413.   if (mode == Off) {
  1414.     command = TestOrd::Off;
  1415.   }
  1416.   else {
  1417.     command = TestOrd::On;
  1418.   }
  1420.   TestOrd::SignalLoggerSpecification logSpec;
  1421.   switch (mode) {
  1422.   case In:
  1423.     logSpec = TestOrd::InputSignals;
  1424.     break;
  1425.   case Out:
  1426.     logSpec = TestOrd::OutputSignals;
  1427.     break;
  1428.   case InOut:
  1429.     logSpec = TestOrd::InputOutputSignals;
  1430.     break;
  1431.   case Off:
  1432.     // In MgmtSrvr interface it's just possible to switch off all logging, both
  1433.     // "in" and "out" (this should probably be changed).
  1434.     logSpec = TestOrd::InputOutputSignals;
  1435.     break;
  1436.   default:
  1437.     ndbout_c("Unexpected value %d, MgmtSrvr::setSignalLoggingMode, line %d",
  1438.      (unsigned)mode, __LINE__);
  1439.     assert(false);
  1440.     return -1;
  1441.   }
  1443.   SimpleSignal ssig;
  1444.   ssig.set(ss,TestOrd::TraceAPI, CMVMI, GSN_TEST_ORD, TestOrd::SignalLength);
  1446.   TestOrd* const testOrd = CAST_PTR(TestOrd, ssig.getDataPtrSend());
  1447.   testOrd->clear();
  1448.   
  1449.   if (blocks.size() == 0 || blocks[0] == "ALL") {
  1450.     // Logg command for all blocks
  1451.     testOrd->addSignalLoggerCommand(command, logSpec);
  1452.   } else {
  1453.     for(unsigned i = 0; i < blocks.size(); i++){
  1454.       int blockNumber = getBlockNumber(blocks[i]);
  1455.       if (blockNumber == -1) {
  1456.         return INVALID_BLOCK_NAME;
  1457.       }
  1458.       testOrd->addSignalLoggerCommand(blockNumber, command, logSpec);
  1459.     } // for
  1460.   } // else
  1462.   return ss.sendSignal(nodeId, &ssig) == SEND_OK ? 0 : SEND_OR_RECEIVE_FAILED;
  1463. }
  1465. /*****************************************************************************
  1466.  * Signal tracing
  1467.  *****************************************************************************/
  1468. int MgmtSrvr::startSignalTracing(int nodeId)
  1469. {
  1470.   INIT_SIGNAL_SENDER(ss,nodeId);
  1471.   
  1472.   SimpleSignal ssig;
  1473.   ssig.set(ss,TestOrd::TraceAPI, CMVMI, GSN_TEST_ORD, TestOrd::SignalLength);
  1475.   TestOrd* const testOrd = CAST_PTR(TestOrd, ssig.getDataPtrSend());
  1476.   testOrd->clear();
  1477.   testOrd->setTestCommand(TestOrd::On);
  1479.   return ss.sendSignal(nodeId, &ssig) == SEND_OK ? 0 : SEND_OR_RECEIVE_FAILED;
  1480. }
  1482. int 
  1483. MgmtSrvr::stopSignalTracing(int nodeId) 
  1484. {
  1485.   INIT_SIGNAL_SENDER(ss,nodeId);
  1487.   SimpleSignal ssig;
  1488.   ssig.set(ss,TestOrd::TraceAPI, CMVMI, GSN_TEST_ORD, TestOrd::SignalLength);
  1489.   TestOrd* const testOrd = CAST_PTR(TestOrd, ssig.getDataPtrSend());
  1490.   testOrd->clear();
  1491.   testOrd->setTestCommand(TestOrd::Off);
  1493.   return ss.sendSignal(nodeId, &ssig) == SEND_OK ? 0 : SEND_OR_RECEIVE_FAILED;
  1494. }
  1497. /*****************************************************************************
  1498.  * Dump state
  1499.  *****************************************************************************/
  1501. int
  1502. MgmtSrvr::dumpState(int nodeId, const char* args)
  1503. {
  1504.   // Convert the space separeted args 
  1505.   // string to an int array
  1506.   Uint32 args_array[25];
  1507.   Uint32 numArgs = 0;
  1509.   char buf[10];  
  1510.   int b  = 0;
  1511.   memset(buf, 0, 10);
  1512.   for (size_t i = 0; i <= strlen(args); i++){
  1513.     if (args[i] == ' ' || args[i] == 0){
  1514.       args_array[numArgs] = atoi(buf);
  1515.       numArgs++;
  1516.       memset(buf, 0, 10);
  1517.       b = 0;
  1518.     } else {
  1519.       buf[b] = args[i];
  1520.       b++;
  1521.     }    
  1522.   }
  1523.   
  1524.   return dumpState(nodeId, args_array, numArgs);
  1525. }
  1527. int
  1528. MgmtSrvr::dumpState(int nodeId, const Uint32 args[], Uint32 no)
  1529. {
  1530.   INIT_SIGNAL_SENDER(ss,nodeId);
  1532.   const Uint32 len = no > 25 ? 25 : no;
  1533.   
  1534.   SimpleSignal ssig;
  1535.   DumpStateOrd * const dumpOrd = 
  1536.     CAST_PTR(DumpStateOrd, ssig.getDataPtrSend());
  1537.   ssig.set(ss,TestOrd::TraceAPI, CMVMI, GSN_DUMP_STATE_ORD, len);
  1538.   for(Uint32 i = 0; i<25; i++){
  1539.     if (i < len)
  1540.       dumpOrd->args[i] = args[i];
  1541.     else
  1542.       dumpOrd->args[i] = 0;
  1543.   }
  1544.   
  1545.   return ss.sendSignal(nodeId, &ssig) == SEND_OK ? 0 : SEND_OR_RECEIVE_FAILED;
  1546. }
  1549. //****************************************************************************
  1550. //****************************************************************************
  1552. const char* MgmtSrvr::getErrorText(int errorCode, char *buf, int buf_sz)
  1553. {
  1555.   for (int i = 0; i < noOfErrorCodes; ++i) {
  1556.     if (errorCode == errorTable[i]._errorCode) {
  1557.       BaseString::snprintf(buf, buf_sz, errorTable[i]._errorText);
  1558.       buf[buf_sz-1]= 0;
  1559.       return buf;
  1560.     }
  1561.   }
  1563.   ndb_error_string(errorCode, buf, buf_sz);
  1564.   buf[buf_sz-1]= 0;
  1566.   return buf;
  1567. }
  1569. void 
  1570. MgmtSrvr::handleReceivedSignal(NdbApiSignal* signal)
  1571. {
  1572.   // The way of handling a received signal is taken from the Ndb class.
  1573.   int returnCode;
  1575.   int gsn = signal->readSignalNumber();
  1577.   switch (gsn) {
  1578.   case GSN_EVENT_SUBSCRIBE_CONF:
  1579.     break;
  1580.   case GSN_EVENT_SUBSCRIBE_REF:
  1581.     break;
  1582.   case GSN_EVENT_REP:
  1583.     eventReport(refToNode(signal->theSendersBlockRef), signal->getDataPtr());
  1584.     break;
  1586.   case GSN_NF_COMPLETEREP:
  1587.     break;
  1588.   case GSN_NODE_FAILREP:
  1589.     break;
  1591.   default:
  1592.     g_eventLogger.error("Unknown signal received. SignalNumber: "
  1593. "%i from (%d, %x)",
  1594. gsn,
  1595. refToNode(signal->theSendersBlockRef),
  1596. refToBlock(signal->theSendersBlockRef));
  1597.   }
  1598.   
  1599.   if (theWaitState == NO_WAIT) {
  1600.     NdbCondition_Signal(theMgmtWaitForResponseCondPtr);
  1601.   }
  1602. }
  1604. void
  1605. MgmtSrvr::handleStatus(NodeId nodeId, bool alive, bool nfComplete)
  1606. {
  1607.   DBUG_ENTER("MgmtSrvr::handleStatus");
  1608.   Uint32 theData[25];
  1609.   theData[1] = nodeId;
  1610.   if (alive) {
  1611.     m_started_nodes.push_back(nodeId);
  1612.     theData[0] = EventReport::Connected;
  1613.   } else {
  1614.     theData[0] = EventReport::Disconnected;
  1615.     if(nfComplete)
  1616.     {
  1617.       DBUG_VOID_RETURN;
  1618.     }
  1619.   }
  1620.   
  1621.   eventReport(_ownNodeId, theData);
  1622.   DBUG_VOID_RETURN;
  1623. }
  1625. //****************************************************************************
  1626. //****************************************************************************
  1628. void 
  1629. MgmtSrvr::signalReceivedNotification(void* mgmtSrvr, 
  1630.                                      NdbApiSignal* signal,
  1631.      LinearSectionPtr ptr[3]) 
  1632. {
  1633.   ((MgmtSrvr*)mgmtSrvr)->handleReceivedSignal(signal);
  1634. }
  1637. //****************************************************************************
  1638. //****************************************************************************
  1639. void 
  1640. MgmtSrvr::nodeStatusNotification(void* mgmSrv, Uint32 nodeId, 
  1641.  bool alive, bool nfComplete)
  1642. {
  1643.   DBUG_ENTER("MgmtSrvr::nodeStatusNotification");
  1644.   DBUG_PRINT("enter",("nodeid= %d, alive= %d, nfComplete= %d", nodeId, alive, nfComplete));
  1645.   ((MgmtSrvr*)mgmSrv)->handleStatus(nodeId, alive, nfComplete);
  1646.   DBUG_VOID_RETURN;
  1647. }
  1649. enum ndb_mgm_node_type 
  1650. MgmtSrvr::getNodeType(NodeId nodeId) const 
  1651. {
  1652.   if(nodeId >= MAX_NODES)
  1653.     return (enum ndb_mgm_node_type)-1;
  1654.   
  1655.   return nodeTypes[nodeId];
  1656. }
  1658. const char *MgmtSrvr::get_connect_address(Uint32 node_id)
  1659. {
  1660.   if (m_connect_address[node_id].s_addr == 0 &&
  1661.       theFacade && theFacade->theTransporterRegistry &&
  1662.       theFacade->theClusterMgr &&
  1663.       getNodeType(node_id) == NDB_MGM_NODE_TYPE_NDB) 
  1664.   {
  1665.     const ClusterMgr::Node &node=
  1666.       theFacade->theClusterMgr->getNodeInfo(node_id);
  1667.     if (node.connected)
  1668.     {
  1669.       m_connect_address[node_id]=
  1670. theFacade->theTransporterRegistry->get_connect_address(node_id);
  1671.     }
  1672.   }
  1673.   return inet_ntoa(m_connect_address[node_id]);  
  1674. }
  1676. void
  1677. MgmtSrvr::get_connected_nodes(NodeBitmask &connected_nodes) const
  1678. {
  1679.   if (theFacade && theFacade->theClusterMgr) 
  1680.   {
  1681.     for(Uint32 i = 0; i < MAX_NODES; i++)
  1682.     {
  1683.       if (getNodeType(i) == NDB_MGM_NODE_TYPE_NDB)
  1684.       {
  1685. const ClusterMgr::Node &node= theFacade->theClusterMgr->getNodeInfo(i);
  1686. if (node.connected)
  1687. {
  1688.   connected_nodes.bitOR(node.m_state.m_connected_nodes);
  1689. }
  1690.       }
  1691.     }
  1692.   }
  1693. }
  1695. bool
  1696. MgmtSrvr::alloc_node_id(NodeId * nodeId, 
  1697. enum ndb_mgm_node_type type,
  1698. struct sockaddr *client_addr, 
  1699. SOCKET_SIZE_TYPE *client_addr_len,
  1700. BaseString &error_string)
  1701. {
  1702.   DBUG_ENTER("MgmtSrvr::alloc_node_id");
  1703.   DBUG_PRINT("enter", ("nodeid=%d, type=%d, client_addr=%d",
  1704.        *nodeId, type, client_addr));
  1705.   if (g_no_nodeid_checks) {
  1706.     if (*nodeId == 0) {
  1707.       error_string.appfmt("no-nodeid-checks set in management server.n"
  1708.   "node id must be set explicitly in connectstring");
  1709.       DBUG_RETURN(false);
  1710.     }
  1711.     DBUG_RETURN(true);
  1712.   }
  1713.   Guard g(m_node_id_mutex);
  1714.   int no_mgm= 0;
  1715.   NodeBitmask connected_nodes(m_reserved_nodes);
  1716.   get_connected_nodes(connected_nodes);
  1717.   {
  1718.     for(Uint32 i = 0; i < MAX_NODES; i++)
  1719.       if (getNodeType(i) == NDB_MGM_NODE_TYPE_MGM)
  1720. no_mgm++;
  1721.   }
  1722.   bool found_matching_id= false;
  1723.   bool found_matching_type= false;
  1724.   bool found_free_node= false;
  1725.   unsigned id_found= 0;
  1726.   const char *config_hostname= 0;
  1727.   struct in_addr config_addr= {0};
  1728.   int r_config_addr= -1;
  1729.   unsigned type_c= 0;
  1731.   ndb_mgm_configuration_iterator
  1732.     iter(*(ndb_mgm_configuration *)_config->m_configValues, CFG_SECTION_NODE);
  1733.   for(iter.first(); iter.valid(); iter.next()) {
  1734.     unsigned tmp= 0;
  1735.     if(iter.get(CFG_NODE_ID, &tmp)) require(false);
  1736.     if (*nodeId && *nodeId != tmp)
  1737.       continue;
  1738.     found_matching_id= true;
  1739.     if(iter.get(CFG_TYPE_OF_SECTION, &type_c)) require(false);
  1740.     if(type_c != (unsigned)type)
  1741.       continue;
  1742.     found_matching_type= true;
  1743.     if (connected_nodes.get(tmp))
  1744.       continue;
  1745.     found_free_node= true;
  1746.     if(iter.get(CFG_NODE_HOST, &config_hostname)) require(false);
  1747.     if (config_hostname && config_hostname[0] == 0)
  1748.       config_hostname= 0;
  1749.     else if (client_addr) {
  1750.       // check hostname compatability
  1751.       const void *tmp_in= &(((sockaddr_in*)client_addr)->sin_addr);
  1752.       if((r_config_addr= Ndb_getInAddr(&config_addr, config_hostname)) != 0
  1753.  || memcmp(&config_addr, tmp_in, sizeof(config_addr)) != 0) {
  1754. struct in_addr tmp_addr;
  1755. if(Ndb_getInAddr(&tmp_addr, "localhost") != 0
  1756.    || memcmp(&tmp_addr, tmp_in, sizeof(config_addr)) != 0) {
  1757.   // not localhost
  1758. #if 0
  1759.   ndbout << "MgmtSrvr::getFreeNodeId compare failed for ""
  1760.  << config_hostname
  1761.  << "" id=" << tmp << endl;
  1762. #endif
  1763.   continue;
  1764. }
  1765. // connecting through localhost
  1766. // check if config_hostname is local
  1767. if (!SocketServer::tryBind(0,config_hostname)) {
  1768.   continue;
  1769. }
  1770.       }
  1771.     } else { // client_addr == 0
  1772.       if (!SocketServer::tryBind(0,config_hostname)) {
  1773. continue;
  1774.       }
  1775.     }
  1776.     if (*nodeId != 0 ||
  1777. type != NDB_MGM_NODE_TYPE_MGM ||
  1778. no_mgm == 1) { // any match is ok
  1780.       if (config_hostname == 0 &&
  1781.   *nodeId == 0 &&
  1782.   type != NDB_MGM_NODE_TYPE_MGM)
  1783.       {
  1784. if (!id_found) // only set if not set earlier
  1785.   id_found= tmp;
  1786. continue; /* continue looking for a nodeid with specified
  1787.    * hostname
  1788.    */
  1789.       }
  1790.       assert(id_found == 0);
  1791.       id_found= tmp;
  1792.       break;
  1793.     }
  1794.     if (id_found) { // mgmt server may only have one match
  1795.       error_string.appfmt("Ambiguous node id's %d and %d.n"
  1796.   "Suggest specifying node id in connectstring,n"
  1797.   "or specifying unique host names in config file.",
  1798.   id_found, tmp);
  1799.       DBUG_RETURN(false);
  1800.     }
  1801.     if (config_hostname == 0) {
  1802.       error_string.appfmt("Ambiguity for node id %d.n"
  1803.   "Suggest specifying node id in connectstring,n"
  1804.   "or specifying unique host names in config file,n"
  1805.   "or specifying just one mgmt server in config file.",
  1806.   tmp);
  1807.       DBUG_RETURN(false);
  1808.     }
  1809.     id_found= tmp; // mgmt server matched, check for more matches
  1810.   }
  1812.   if (id_found)
  1813.   {
  1814.     *nodeId= id_found;
  1815.     DBUG_PRINT("info", ("allocating node id %d",*nodeId));
  1816.     {
  1817.       int r= 0;
  1818.       if (client_addr)
  1819. m_connect_address[id_found]=
  1820.   ((struct sockaddr_in *)client_addr)->sin_addr;
  1821.       else if (config_hostname)
  1822. r= Ndb_getInAddr(&(m_connect_address[id_found]), config_hostname);
  1823.       else {
  1824. char name[256];
  1825. r= gethostname(name, sizeof(name));
  1826. if (r == 0) {
  1827.   name[sizeof(name)-1]= 0;
  1828.   r= Ndb_getInAddr(&(m_connect_address[id_found]), name);
  1829. }
  1830.       }
  1831.       if (r)
  1832. m_connect_address[id_found].s_addr= 0;
  1833.     }
  1834.     m_reserved_nodes.set(id_found);
  1835.     char tmp_str[128];
  1836.     m_reserved_nodes.getText(tmp_str);
  1837.     g_eventLogger.info("Mgmt server state: nodeid %d reserved for ip %s, m_reserved_nodes %s.",
  1838.        id_found, get_connect_address(id_found), tmp_str);
  1839.     DBUG_RETURN(true);
  1840.   }
  1842.   if (found_matching_type && !found_free_node) {
  1843.     // we have a temporary error which might be due to that 
  1844.     // we have got the latest connect status from db-nodes.  Force update.
  1845.     global_flag_send_heartbeat_now= 1;
  1846.   }
  1848.   BaseString type_string, type_c_string;
  1849.   {
  1850.     const char *alias, *str;
  1851.     alias= ndb_mgm_get_node_type_alias_string(type, &str);
  1852.     type_string.assfmt("%s(%s)", alias, str);
  1853.     alias= ndb_mgm_get_node_type_alias_string((enum ndb_mgm_node_type)type_c,
  1854.       &str);
  1855.     type_c_string.assfmt("%s(%s)", alias, str);
  1856.   }
  1858.   if (*nodeId == 0) {
  1859.     if (found_matching_id)
  1860.       if (found_matching_type)
  1861. if (found_free_node)
  1862.   error_string.appfmt("Connection done from wrong host ip %s.",
  1863.       (client_addr)?
  1864.         inet_ntoa(((struct sockaddr_in *)
  1865.  (client_addr))->sin_addr):"");
  1866. else
  1867.   error_string.appfmt("No free node id found for %s.",
  1868.       type_string.c_str());
  1869.       else
  1870. error_string.appfmt("No %s node defined in config file.",
  1871.     type_string.c_str());
  1872.     else
  1873.       error_string.append("No nodes defined in config file.");
  1874.   } else {
  1875.     if (found_matching_id)
  1876.       if (found_matching_type)
  1877. if (found_free_node) {
  1878.   // have to split these into two since inet_ntoa overwrites itself
  1879.   error_string.appfmt("Connection with id %d done from wrong host ip %s,",
  1880.       *nodeId, inet_ntoa(((struct sockaddr_in *)
  1881.   (client_addr))->sin_addr));
  1882.   error_string.appfmt(" expected %s(%s).", config_hostname,
  1883.       r_config_addr ?
  1884.       "lookup failed" : inet_ntoa(config_addr));
  1885. } else
  1886.   error_string.appfmt("Id %d already allocated by another node.",
  1887.       *nodeId);
  1888.       else
  1889. error_string.appfmt("Id %d configured as %s, connect attempted as %s.",
  1890.     *nodeId, type_c_string.c_str(),
  1891.     type_string.c_str());
  1892.     else
  1893.       error_string.appfmt("No node defined with id=%d in config file.",
  1894.   *nodeId);
  1895.   }
  1897.   g_eventLogger.warning("Allocate nodeid (%d) failed. Connection from ip %s. "
  1898. "Returned error string "%s"",
  1899. *nodeId,
  1900. client_addr != 0 ? inet_ntoa(((struct sockaddr_in *)(client_addr))->sin_addr) : "<none>",
  1901. error_string.c_str());
  1903.   NodeBitmask connected_nodes2;
  1904.   get_connected_nodes(connected_nodes2);
  1905.   {
  1906.     BaseString tmp_connected, tmp_not_connected;
  1907.     for(Uint32 i = 0; i < MAX_NODES; i++)
  1908.     {
  1909.       if (connected_nodes2.get(i))
  1910.       {
  1911. if (!m_reserved_nodes.get(i))
  1912.   tmp_connected.appfmt(" %d", i);
  1913.       }
  1914.       else if (m_reserved_nodes.get(i))
  1915.       {
  1916. tmp_not_connected.appfmt(" %d", i);
  1917.       }
  1918.     }
  1919.     if (tmp_connected.length() > 0)
  1920.       g_eventLogger.info("Mgmt server state: node id's %s connected but not reserved", 
  1921.  tmp_connected.c_str());
  1922.     if (tmp_not_connected.length() > 0)
  1923.       g_eventLogger.info("Mgmt server state: node id's %s not connected but reserved",
  1924.  tmp_not_connected.c_str());
  1925.   }
  1926.   DBUG_RETURN(false);
  1927. }
  1929. bool
  1930. MgmtSrvr::getNextNodeId(NodeId * nodeId, enum ndb_mgm_node_type type) const 
  1931. {
  1932.   NodeId tmp = * nodeId;
  1934.   tmp++;
  1935.   while(nodeTypes[tmp] != type && tmp < MAX_NODES)
  1936.     tmp++;
  1937.   
  1938.   if(tmp == MAX_NODES){
  1939.     return false;
  1940.   }
  1942.   * nodeId = tmp;
  1943.   return true;
  1944. }
  1946. #include "Services.hpp"
  1948. void
  1949. MgmtSrvr::eventReport(NodeId nodeId, const Uint32 * theData)
  1950. {
  1951.   const EventReport * const eventReport = (EventReport *)&theData[0];
  1952.   
  1953.   EventReport::EventType type = eventReport->getEventType();
  1954.   // Log event
  1955.   g_eventLogger.log(type, theData, nodeId, 
  1956.     &m_event_listner[0].m_logLevel);  
  1957.   m_event_listner.log(type, theData, nodeId);
  1958. }
  1960. /***************************************************************************
  1961.  * Backup
  1962.  ***************************************************************************/
  1964. int
  1965. MgmtSrvr::startBackup(Uint32& backupId, int waitCompleted)
  1966. {
  1967.   SignalSender ss(theFacade);
  1968.   ss.lock(); // lock will be released on exit
  1970.   bool next;
  1971.   NodeId nodeId = 0;
  1972.   while((next = getNextNodeId(&nodeId, NDB_MGM_NODE_TYPE_NDB)) == true &&
  1973. theFacade->get_node_alive(nodeId) == false);
  1974.   
  1975.   if(!next) return NO_CONTACT_WITH_DB_NODES;
  1977.   SimpleSignal ssig;
  1978.   BackupReq* req = CAST_PTR(BackupReq, ssig.getDataPtrSend());
  1979.   ssig.set(ss, TestOrd::TraceAPI, BACKUP, GSN_BACKUP_REQ, 
  1980.    BackupReq::SignalLength);
  1981.   
  1982.   req->senderData = 19;
  1983.   req->backupDataLen = 0;
  1984.   assert(waitCompleted < 3);
  1985.   req->flags = waitCompleted & 0x3;
  1987.   BackupEvent event;
  1988.   int do_send = 1;
  1989.   while (1) {
  1990.     if (do_send)
  1991.     {
  1992.       if (ss.sendSignal(nodeId, &ssig) != SEND_OK) {
  1993. return SEND_OR_RECEIVE_FAILED;
  1994.       }
  1995.       if (waitCompleted == 0)
  1996. return 0;
  1997.       do_send = 0;
  1998.     }
  1999.     SimpleSignal *signal = ss.waitFor();
  2001.     int gsn = signal->readSignalNumber();
  2002.     switch (gsn) {
  2003.     case GSN_BACKUP_CONF:{
  2004.       const BackupConf * const conf = 
  2005. CAST_CONSTPTR(BackupConf, signal->getDataPtr());
  2006.       event.Event = BackupEvent::BackupStarted;
  2007.       event.Started.BackupId = conf->backupId;
  2008.       event.Nodes = conf->nodes;
  2009. #ifdef VM_TRACE
  2010.       ndbout_c("Backup(%d) master is %d", conf->backupId,
  2011.        refToNode(signal->header.theSendersBlockRef));
  2012. #endif
  2013.       backupId = conf->backupId;
  2014.       if (waitCompleted == 1)
  2015. return 0;
  2016.       // wait for next signal
  2017.       break;
  2018.     }
  2019.     case GSN_BACKUP_COMPLETE_REP:{
  2020.       const BackupCompleteRep * const rep = 
  2021. CAST_CONSTPTR(BackupCompleteRep, signal->getDataPtr());
  2022. #ifdef VM_TRACE
  2023.       ndbout_c("Backup(%d) completed %d", rep->backupId);
  2024. #endif
  2025.       event.Event = BackupEvent::BackupCompleted;
  2026.       event.Completed.BackupId = rep->backupId;
  2027.     
  2028.       event.Completed.NoOfBytes = rep->noOfBytes;
  2029.       event.Completed.NoOfLogBytes = rep->noOfLogBytes;
  2030.       event.Completed.NoOfRecords = rep->noOfRecords;
  2031.       event.Completed.NoOfLogRecords = rep->noOfLogRecords;
  2032.       event.Completed.stopGCP = rep->stopGCP;
  2033.       event.Completed.startGCP = rep->startGCP;
  2034.       event.Nodes = rep->nodes;
  2036.       backupId = rep->backupId;
  2037.       return 0;
  2038.     }
  2039.     case GSN_BACKUP_REF:{
  2040.       const BackupRef * const ref = 
  2041. CAST_CONSTPTR(BackupRef, signal->getDataPtr());
  2042.       if(ref->errorCode == BackupRef::IAmNotMaster){
  2043. nodeId = refToNode(ref->masterRef);
  2044. #ifdef VM_TRACE
  2045. ndbout_c("I'm not master resending to %d", nodeId);
  2046. #endif
  2047. do_send = 1; // try again
  2048. continue;
  2049.       }
  2050.       event.Event = BackupEvent::BackupFailedToStart;
  2051.       event.FailedToStart.ErrorCode = ref->errorCode;
  2052.       return ref->errorCode;
  2053.     }
  2054.     case GSN_BACKUP_ABORT_REP:{
  2055.       const BackupAbortRep * const rep = 
  2056. CAST_CONSTPTR(BackupAbortRep, signal->getDataPtr());
  2057.       event.Event = BackupEvent::BackupAborted;
  2058.       event.Aborted.Reason = rep->reason;
  2059.       event.Aborted.BackupId = rep->backupId;
  2060.       event.Aborted.ErrorCode = rep->reason;
  2061. #ifdef VM_TRACE
  2062.       ndbout_c("Backup %d aborted", rep->backupId);
  2063. #endif
  2064.       return rep->reason;
  2065.     }
  2066.     case GSN_NF_COMPLETEREP:{
  2067.       const NFCompleteRep * const rep =
  2068. CAST_CONSTPTR(NFCompleteRep, signal->getDataPtr());
  2069. #ifdef VM_TRACE
  2070.       ndbout_c("Node %d fail completed", rep->failedNodeId);
  2071. #endif
  2072.       if (rep->failedNodeId == nodeId ||
  2073.   waitCompleted == 1)
  2074. return 1326;
  2075.       // wait for next signal
  2076.       // master node will report aborted backup
  2077.       break;
  2078.     }
  2079.     case GSN_NODE_FAILREP:{
  2080.       const NodeFailRep * const rep =
  2081. CAST_CONSTPTR(NodeFailRep, signal->getDataPtr());
  2082.       if (NodeBitmask::get(rep->theNodes,nodeId) ||
  2083.   waitCompleted == 1)
  2084. return 1326;
  2085.       // wait for next signal
  2086.       // master node will report aborted backup
  2087.       break;
  2088.     }
  2089.     default:
  2090.       report_unknown_signal(signal);
  2091.       return SEND_OR_RECEIVE_FAILED;
  2092.     }
  2093.   }
  2094. }
  2096. int 
  2097. MgmtSrvr::abortBackup(Uint32 backupId)
  2098. {
  2099.   SignalSender ss(theFacade);
  2101.   bool next;
  2102.   NodeId nodeId = 0;
  2103.   while((next = getNextNodeId(&nodeId, NDB_MGM_NODE_TYPE_NDB)) == true &&
  2104. theFacade->get_node_alive(nodeId) == false);
  2105.   
  2106.   if(!next){
  2107.     return NO_CONTACT_WITH_DB_NODES;
  2108.   }
  2109.   
  2110.   SimpleSignal ssig;
  2112.   AbortBackupOrd* ord = CAST_PTR(AbortBackupOrd, ssig.getDataPtrSend());
  2113.   ssig.set(ss, TestOrd::TraceAPI, BACKUP, GSN_ABORT_BACKUP_ORD, 
  2114.    AbortBackupOrd::SignalLength);
  2115.   
  2116.   ord->requestType = AbortBackupOrd::ClientAbort;
  2117.   ord->senderData = 19;
  2118.   ord->backupId = backupId;
  2119.   
  2120.   return ss.sendSignal(nodeId, &ssig) == SEND_OK ? 0 : SEND_OR_RECEIVE_FAILED;
  2121. }
  2124. /*****************************************************************************
  2125.  * Global Replication
  2126.  *****************************************************************************/
  2128. int
  2129. MgmtSrvr::repCommand(Uint32* repReqId, Uint32 request, bool waitCompleted)
  2130. {
  2131.   require(false);
  2132.   return 0;
  2133. }
  2135. MgmtSrvr::Allocated_resources::Allocated_resources(MgmtSrvr &m)
  2136.   : m_mgmsrv(m)
  2137. {
  2138. }
  2140. MgmtSrvr::Allocated_resources::~Allocated_resources()
  2141. {
  2142.   Guard g(m_mgmsrv.m_node_id_mutex);
  2143.   if (!m_reserved_nodes.isclear()) {
  2144.     m_mgmsrv.m_reserved_nodes.bitANDC(m_reserved_nodes); 
  2145.     // node has been reserved, force update signal to ndb nodes
  2146.     global_flag_send_heartbeat_now= 1;
  2148.     char tmp_str[128];
  2149.     m_mgmsrv.m_reserved_nodes.getText(tmp_str);
  2150.     g_eventLogger.info("Mgmt server state: nodeid %d freed, m_reserved_nodes %s.",
  2151.        get_nodeid(), tmp_str);
  2152.   }
  2153. }
  2155. void
  2156. MgmtSrvr::Allocated_resources::reserve_node(NodeId id)
  2157. {
  2158.   m_reserved_nodes.set(id);
  2159. }
  2161. NodeId
  2162. MgmtSrvr::Allocated_resources::get_nodeid() const
  2163. {
  2164.   for(Uint32 i = 0; i < MAX_NODES; i++)
  2165.   {
  2166.     if (m_reserved_nodes.get(i))
  2167.       return i;
  2168.   }
  2169.   return 0;
  2170. }
  2172. int
  2173. MgmtSrvr::setDbParameter(int node, int param, const char * value,
  2174.  BaseString& msg){
  2175.   /**
  2176.    * Check parameter
  2177.    */
  2178.   ndb_mgm_configuration_iterator iter(* _config->m_configValues, 
  2179.       CFG_SECTION_NODE);
  2180.   if(iter.first() != 0){
  2181.     msg.assign("Unable to find node section (iter.first())");
  2182.     return -1;
  2183.   }
  2184.   
  2185.   Uint32 type = NODE_TYPE_DB + 1;
  2186.   if(node != 0){
  2187.     if(iter.find(CFG_NODE_ID, node) != 0){
  2188.       msg.assign("Unable to find node (iter.find())");
  2189.       return -1;
  2190.     }
  2191.     if(iter.get(CFG_TYPE_OF_SECTION, &type) != 0){
  2192.       msg.assign("Unable to get node type(iter.get(CFG_TYPE_OF_SECTION))");
  2193.       return -1;
  2194.     }
  2195.   } else {
  2196.     do {
  2197.       if(iter.get(CFG_TYPE_OF_SECTION, &type) != 0){
  2198. msg.assign("Unable to get node type(iter.get(CFG_TYPE_OF_SECTION))");
  2199. return -1;
  2200.       }
  2201.       if(type == NODE_TYPE_DB)
  2202. break;
  2203.     } while(iter.next() == 0);
  2204.   }
  2205.   
  2206.   if(type != NODE_TYPE_DB){
  2207.     msg.assfmt("Invalid node type or no such node (%d %d)", 
  2208.        type, NODE_TYPE_DB);
  2209.     return -1;
  2210.   }
  2212.   int p_type;
  2213.   unsigned val_32;
  2214.   Uint64 val_64;
  2215.   const char * val_char;
  2216.   do {
  2217.     p_type = 0;
  2218.     if(iter.get(param, &val_32) == 0){
  2219.       val_32 = atoi(value);
  2220.       break;
  2221.     }
  2222.     
  2223.     p_type++;
  2224.     if(iter.get(param, &val_64) == 0){
  2225.       val_64 = strtoll(value, 0, 10);
  2226.       break;
  2227.     }
  2228.     p_type++;
  2229.     if(iter.get(param, &val_char) == 0){
  2230.       val_char = value;
  2231.       break;
  2232.     }
  2233.     msg.assign("Could not get parameter");
  2234.     return -1;
  2235.   } while(0);
  2236.   
  2237.   bool res = false;
  2238.   do {
  2239.     int ret = iter.get(CFG_TYPE_OF_SECTION, &type);
  2240.     assert(ret == 0);
  2241.     
  2242.     if(type != NODE_TYPE_DB)
  2243.       continue;
  2244.     
  2245.     Uint32 node;
  2246.     ret = iter.get(CFG_NODE_ID, &node);
  2247.     assert(ret == 0);
  2248.     
  2249.     ConfigValues::Iterator i2(_config->m_configValues->m_config, 
  2250.       iter.m_config);
  2251.     switch(p_type){
  2252.     case 0:
  2253.       res = i2.set(param, val_32);
  2254.       ndbout_c("Updating node %d param: %d to %d",  node, param, val_32);
  2255.       break;
  2256.     case 1:
  2257.       res = i2.set(param, val_64);
  2258.       ndbout_c("Updating node %d param: %d to %Ld",  node, param, val_32);
  2259.       break;
  2260.     case 2:
  2261.       res = i2.set(param, val_char);
  2262.       ndbout_c("Updating node %d param: %d to %s",  node, param, val_char);
  2263.       break;
  2264.     default:
  2265.       require(false);
  2266.     }
  2267.     assert(res);
  2268.   } while(node == 0 && iter.next() == 0);
  2270.   msg.assign("Success");
  2271.   return 0;
  2272. }
  2274. template class MutexVector<unsigned short>;
  2275. template class MutexVector<Ndb_mgmd_event_service::Event_listener>;
  2276. template class MutexVector<EventSubscribeReq>;