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

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

MySQL数据库

开发平台：

Visual C++

mgmapi.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_sys.h>
  20. #include <LocalConfig.hpp>
  21. #include <NdbAutoPtr.hpp>
  23. #include <NdbSleep.h>
  24. #include <NdbTCP.h>
  25. #include "mgmapi.h"
  26. #include "mgmapi_debug.h"
  27. #include "mgmapi_configuration.hpp"
  28. #include <socket_io.h>
  30. #include <NdbOut.hpp>
  31. #include <SocketServer.hpp>
  32. #include <SocketClient.hpp>
  33. #include <Parser.hpp>
  34. #include <OutputStream.hpp>
  35. #include <InputStream.hpp>
  36. #include <Base64.hpp>
  39. #define MGM_CMD(name, fun, desc) 
  40.  { name, 
  41.    0, 
  42.    ParserRow<ParserDummy>::Cmd, 
  43.    ParserRow<ParserDummy>::String, 
  44.    ParserRow<ParserDummy>::Optional, 
  45.    ParserRow<ParserDummy>::IgnoreMinMax, 
  46.    0, 0, 
  47.    fun, 
  48.    desc, 0 }
  50. #define MGM_ARG(name, type, opt, desc) 
  51.  { name, 
  52.    0, 
  53.    ParserRow<ParserDummy>::Arg, 
  54.    ParserRow<ParserDummy>::type, 
  55.    ParserRow<ParserDummy>::opt, 
  56.    ParserRow<ParserDummy>::IgnoreMinMax, 
  57.    0, 0, 
  58.    0, 
  59.    desc, 0 }
  61. #define MGM_END() 
  62.  { 0, 
  63.    0, 
  64.    ParserRow<ParserDummy>::Arg, 
  65.    ParserRow<ParserDummy>::Int, 
  66.    ParserRow<ParserDummy>::Optional, 
  67.    ParserRow<ParserDummy>::IgnoreMinMax, 
  68.    0, 0, 
  69.    0, 
  70.    0, 0 }
  72. class ParserDummy : private SocketServer::Session 
  73. {
  74. public:
  75.   ParserDummy(NDB_SOCKET_TYPE sock);
  76. };
  78. ParserDummy::ParserDummy(NDB_SOCKET_TYPE sock) : SocketServer::Session(sock) 
  79. {
  80. }
  82. typedef Parser<ParserDummy> Parser_t;
  84. #define NDB_MGM_MAX_ERR_DESC_SIZE 256
  86. struct ndb_mgm_handle {
  87.   int cfg_i;
  88.   
  89.   int connected;
  90.   int last_error;
  91.   int last_error_line;
  92.   char last_error_desc[NDB_MGM_MAX_ERR_DESC_SIZE];
  93.   int read_timeout;
  94.   int write_timeout;
  96.   NDB_SOCKET_TYPE socket;
  98.   LocalConfig cfg;
  100. #ifdef MGMAPI_LOG
  101.   FILE* logfile;
  102. #endif
  103.   FILE *errstream;
  104. };
  106. #define SET_ERROR(h, e, s) setError(h, e, __LINE__, s)
  108. static
  109. void
  110. setError(NdbMgmHandle h, int error, int error_line, const char * msg, ...){
  112.   h->last_error = error;  
  113.   h->last_error_line = error_line;
  115.   va_list ap;
  116.   va_start(ap, msg);
  117.   BaseString::vsnprintf(h->last_error_desc, sizeof(h->last_error_desc), msg, ap);
  118.   va_end(ap);
  119. }
  121. #define CHECK_HANDLE(handle, ret) 
  122.   if(handle == 0) { 
  123.     SET_ERROR(handle, NDB_MGM_ILLEGAL_SERVER_HANDLE, ""); 
  124.     return ret; 
  125.   } 
  127. #define CHECK_CONNECTED(handle, ret) 
  128.   if (handle->connected != 1) { 
  129.     SET_ERROR(handle, NDB_MGM_SERVER_NOT_CONNECTED , ""); 
  130.     return ret; 
  131.   }
  133. #define CHECK_REPLY(reply, ret) 
  134.   if(reply == NULL) { 
  135.     SET_ERROR(handle, NDB_MGM_ILLEGAL_SERVER_REPLY, ""); 
  136.     return ret; 
  137.   }
  139. /*****************************************************************************
  140.  * Handles
  141.  *****************************************************************************/
  143. extern "C"
  144. NdbMgmHandle
  145. ndb_mgm_create_handle()
  146. {
  147.   DBUG_ENTER("ndb_mgm_create_handle");
  148.   NdbMgmHandle h     =
  149.     (NdbMgmHandle)my_malloc(sizeof(ndb_mgm_handle),MYF(MY_WME));
  150.   h->connected       = 0;
  151.   h->last_error      = 0;
  152.   h->last_error_line = 0;
  153.   h->socket          = NDB_INVALID_SOCKET;
  154.   h->read_timeout    = 50000;
  155.   h->write_timeout   = 100;
  156.   h->cfg_i           = 0;
  157.   h->errstream       = stdout;
  159.   strncpy(h->last_error_desc, "No error", NDB_MGM_MAX_ERR_DESC_SIZE);
  161.   new (&(h->cfg)) LocalConfig;
  162.   h->cfg.init(0, 0);
  164. #ifdef MGMAPI_LOG
  165.   h->logfile = 0;
  166. #endif
  168.   DBUG_PRINT("exit",("ret: %lx", h));
  169.   DBUG_RETURN(h);
  170. }
  172. extern "C"
  173. int
  174. ndb_mgm_set_connectstring(NdbMgmHandle handle, const char * mgmsrv)
  175. {
  176.   handle->cfg.~LocalConfig();
  177.   new (&(handle->cfg)) LocalConfig;
  178.   if (!handle->cfg.init(mgmsrv, 0) ||
  179.       handle->cfg.ids.size() == 0)
  180.   {
  181.     handle->cfg.~LocalConfig();
  182.     new (&(handle->cfg)) LocalConfig;
  183.     handle->cfg.init(0, 0); /* reset the LocalCongig */
  184.     SET_ERROR(handle, NDB_MGM_ILLEGAL_CONNECT_STRING, "");
  185.     return -1;
  186.   }
  187.   handle->cfg_i= 0;
  188.   return 0;
  189. }
  191. /**
  192.  * Destroy a handle
  193.  */
  194. extern "C"
  195. void
  196. ndb_mgm_destroy_handle(NdbMgmHandle * handle)
  197. {
  198.   DBUG_ENTER("ndb_mgm_destroy_handle");
  199.   if(!handle)
  200.     return;
  201.   DBUG_PRINT("enter",("*handle: %lx", *handle));
  203.   if((* handle)->connected){
  204.     ndb_mgm_disconnect(* handle);
  205.   }
  206. #ifdef MGMAPI_LOG
  207.   if ((* handle)->logfile != 0){
  208.     fclose((* handle)->logfile);
  209.     (* handle)->logfile = 0;
  210.   }
  211. #endif
  212.   (*handle)->cfg.~LocalConfig();
  213.   my_free((char*)* handle,MYF(MY_ALLOW_ZERO_PTR));
  214.   * handle = 0;
  215.   DBUG_VOID_RETURN;
  216. }
  218. extern "C" 
  219. void
  220. ndb_mgm_set_error_stream(NdbMgmHandle handle, FILE * file)
  221. {
  222.   handle->errstream = file;
  223. }
  225. /*****************************************************************************
  226.  * Error handling
  227.  *****************************************************************************/
  229. /**
  230.  * Get latest error associated with a handle
  231.  */
  232. extern "C"
  233. int
  234. ndb_mgm_get_latest_error(const NdbMgmHandle h)
  235. {
  236.   return h->last_error;
  237. }
  239. extern "C"
  240. const char *
  241. ndb_mgm_get_latest_error_desc(const NdbMgmHandle h){
  242.   return h->last_error_desc;
  243. }
  245. extern "C"
  246. int
  247. ndb_mgm_get_latest_error_line(const NdbMgmHandle h)
  248. {
  249.   return h->last_error_line;
  250. }
  252. extern "C"
  253. const char *
  254. ndb_mgm_get_latest_error_msg(const NdbMgmHandle h)
  255. {
  256.   for (int i=0; i<ndb_mgm_noOfErrorMsgs; i++) {
  257.     if (ndb_mgm_error_msgs[i].code == h->last_error)
  258.       return ndb_mgm_error_msgs[i].msg;
  259.   }
  261.   return "Error"; // Unknown Error message
  262. }
  264. /*
  265.  * Call an operation, and return the reply
  266.  */
  267. static const Properties *
  268. ndb_mgm_call(NdbMgmHandle handle, const ParserRow<ParserDummy> *command_reply,
  269.      const char *cmd, const Properties *cmd_args) 
  270. {
  271.   DBUG_ENTER("ndb_mgm_call");
  272.   DBUG_PRINT("enter",("handle->socket: %d, cmd: %s",
  273.       handle->socket, cmd));
  274.   SocketOutputStream out(handle->socket);
  275.   SocketInputStream in(handle->socket, handle->read_timeout);
  277.   out.println(cmd);
  278. #ifdef MGMAPI_LOG
  279.   /** 
  280.    * Print command to  log file
  281.    */
  282.   FileOutputStream f(handle->logfile);
  283.   f.println("OUT: %s", cmd);
  284. #endif
  286.   if(cmd_args != NULL) {
  287.     Properties::Iterator iter(cmd_args);
  288.     const char *name;
  289.     while((name = iter.next()) != NULL) {
  290.       PropertiesType t;
  291.       Uint32 val_i;
  292.       Uint64 val_64;
  293.       BaseString val_s;
  295.       cmd_args->getTypeOf(name, &t);
  296.       switch(t) {
  297.       case PropertiesType_Uint32:
  298. cmd_args->get(name, &val_i);
  299. out.println("%s: %d", name, val_i);
  300. break;
  301.       case PropertiesType_Uint64:
  302. cmd_args->get(name, &val_64);
  303. out.println("%s: %Ld", name, val_64);
  304. break;
  305.       case PropertiesType_char:
  306. cmd_args->get(name, val_s);
  307. out.println("%s: %s", name, val_s.c_str());
  308. break;
  309.       case PropertiesType_Properties:
  310. /* Ignore */
  311. break;
  312.       }
  313.     }
  314. #ifdef MGMAPI_LOG
  315.   /** 
  316.    * Print arguments to  log file
  317.    */
  318.   cmd_args->print(handle->logfile, "OUT: ");
  319. #endif
  320.   }
  321.   out.println("");
  323.   Parser_t::Context ctx;
  324.   ParserDummy session(handle->socket);
  325.   Parser_t parser(command_reply, in, true, true, true);
  327. #if 1
  328.   const Properties* p = parser.parse(ctx, session);
  329.   if (p == NULL){
  330.     /**
  331.      * Print some info about why the parser returns NULL
  332.      */
  333.     DBUG_PRINT("info",("ctx.status: %d, ctx.m_currentToken: %s",
  334.        ctx.m_status, ctx.m_currentToken));
  335.     //ndbout << " status=" << ctx.m_status << ", curr="
  336.     //<< ctx.m_currentToken << endl;
  337.   } 
  338. #ifdef MGMAPI_LOG
  339.   else {
  340.     /** 
  341.      * Print reply to log file
  342.      */
  343.     p->print(handle->logfile, "IN: ");
  344.   }
  345. #endif
  346.   DBUG_RETURN(p);
  347. #else
  348.   DBUG_RETURN(parser.parse(ctx, session));
  349. #endif
  350. }
  352. /**
  353.  * Connect to a management server
  354.  */
  355. extern "C"
  356. int
  357. ndb_mgm_connect(NdbMgmHandle handle, int no_retries,
  358. int retry_delay_in_seconds, int verbose)
  359. {
  360.   SET_ERROR(handle, NDB_MGM_NO_ERROR, "Executing: ndb_mgm_connect");
  361.   CHECK_HANDLE(handle, -1);
  363. #ifdef MGMAPI_LOG
  364.   /**
  365.   * Open the log file
  366.   */
  367.   char logname[64];
  368.   BaseString::snprintf(logname, 64, "mgmapi.log");
  369.   handle->logfile = fopen(logname, "w");
  370. #endif
  372.   /**
  373.    * Do connect
  374.    */
  375.   LocalConfig &cfg= handle->cfg;
  376.   NDB_SOCKET_TYPE sockfd= NDB_INVALID_SOCKET;
  377.   Uint32 i;
  378.   while (sockfd == NDB_INVALID_SOCKET)
  379.   {
  380.     // do all the mgmt servers
  381.     for (i = 0; i < cfg.ids.size(); i++)
  382.     {
  383.       if (cfg.ids[i].type != MgmId_TCP)
  384. continue;
  385.       SocketClient s(cfg.ids[i].name.c_str(), cfg.ids[i].port);
  386.       sockfd = s.connect();
  387.       if (sockfd != NDB_INVALID_SOCKET)
  388. break;
  389.     }
  390.     if (sockfd != NDB_INVALID_SOCKET)
  391.       break;
  392.     if (verbose > 0) {
  393.       char buf[1024];
  394.       fprintf(handle->errstream, "Unable to connect with connect string: %sn",
  395.       cfg.makeConnectString(buf,sizeof(buf)));
  396.       verbose= -1;
  397.     }
  398.     if (no_retries == 0) {
  399.       char buf[1024];
  400.       setError(handle, NDB_MGM_COULD_NOT_CONNECT_TO_SOCKET, __LINE__,
  401.        "Unable to connect with connect string: %s",
  402.        cfg.makeConnectString(buf,sizeof(buf)));
  403.       if (verbose == -2)
  404. fprintf(handle->errstream, ", failed.n");
  405.       return -1;
  406.     }
  407.     if (verbose == -1) {
  408.       fprintf(handle->errstream, "Retrying every %d seconds", 
  409.       retry_delay_in_seconds);
  410.       if (no_retries > 0)
  411. fprintf(handle->errstream, ". Attempts left:");
  412.       else
  413. fprintf(handle->errstream, ", until connected.");
  414.       fflush(handle->errstream);
  415.       verbose= -2;
  416.     }
  417.     if (no_retries > 0) {
  418.       if (verbose == -2) {
  419. fprintf(handle->errstream, " %d", no_retries);
  420. fflush(handle->errstream);
  421.       }
  422.       no_retries--;
  423.     }
  424.     NdbSleep_SecSleep(retry_delay_in_seconds);
  425.   }
  426.   if (verbose == -2)
  427.   {
  428.     fprintf(handle->errstream, "n");
  429.     fflush(handle->errstream);
  430.   }
  431.   handle->cfg_i = i;
  432.   
  433.   handle->socket    = sockfd;
  434.   handle->connected = 1;
  436.   return 0;
  437. }
  439. /**
  440.  * Disconnect from a mgm server
  441.  */
  442. extern "C"
  443. int
  444. ndb_mgm_disconnect(NdbMgmHandle handle)
  445. {
  446.   SET_ERROR(handle, NDB_MGM_NO_ERROR, "Executing: ndb_mgm_disconnect");
  447.   CHECK_HANDLE(handle, -1);
  448.   CHECK_CONNECTED(handle, -1);
  450.   NDB_CLOSE_SOCKET(handle->socket);
  451.   handle->socket = NDB_INVALID_SOCKET;
  452.   handle->connected = 0;
  454.   return 0;
  455. }
  457. struct ndb_mgm_type_atoi 
  458. {
  459.   const char * str;
  460.   const char * alias;
  461.   enum ndb_mgm_node_type value;
  462. };
  464. static struct ndb_mgm_type_atoi type_values[] = 
  465. {
  466.   { "NDB", "ndbd", NDB_MGM_NODE_TYPE_NDB},
  467.   { "API", "mysqld", NDB_MGM_NODE_TYPE_API },
  468.   { "MGM", "ndb_mgmd", NDB_MGM_NODE_TYPE_MGM }
  469. };
  471. const int no_of_type_values = (sizeof(type_values) / 
  472.        sizeof(ndb_mgm_type_atoi));
  474. extern "C"
  475. ndb_mgm_node_type
  476. ndb_mgm_match_node_type(const char * type)
  477. {
  478.   if(type == 0)
  479.     return NDB_MGM_NODE_TYPE_UNKNOWN;
  480.   
  481.   for(int i = 0; i<no_of_type_values; i++)
  482.     if(strcmp(type, type_values[i].str) == 0)
  483.       return type_values[i].value;
  484.     else if(strcmp(type, type_values[i].alias) == 0)
  485.       return type_values[i].value;
  486.   
  487.   return NDB_MGM_NODE_TYPE_UNKNOWN;
  488. }
  490. extern "C"
  491. const char * 
  492. ndb_mgm_get_node_type_string(enum ndb_mgm_node_type type)
  493. {
  494.   for(int i = 0; i<no_of_type_values; i++)
  495.     if(type_values[i].value == type)
  496.       return type_values[i].str;
  497.   return 0;
  498. }
  500. extern "C"
  501. const char * 
  502. ndb_mgm_get_node_type_alias_string(enum ndb_mgm_node_type type, const char** str)
  503. {
  504.   for(int i = 0; i<no_of_type_values; i++)
  505.     if(type_values[i].value == type)
  506.       {
  507. if (str)
  508.   *str= type_values[i].str;
  509. return type_values[i].alias;
  510.       }
  511.   return 0;
  512. }
  514. struct ndb_mgm_status_atoi {
  515.   const char * str;
  516.   enum ndb_mgm_node_status value;
  517. };
  519. static struct ndb_mgm_status_atoi status_values[] = 
  520. {
  521.   { "UNKNOWN", NDB_MGM_NODE_STATUS_UNKNOWN },
  522.   { "NO_CONTACT", NDB_MGM_NODE_STATUS_NO_CONTACT },
  523.   { "NOT_STARTED", NDB_MGM_NODE_STATUS_NOT_STARTED },
  524.   { "STARTING", NDB_MGM_NODE_STATUS_STARTING },
  525.   { "STARTED", NDB_MGM_NODE_STATUS_STARTED },
  526.   { "SHUTTING_DOWN", NDB_MGM_NODE_STATUS_SHUTTING_DOWN },
  527.   { "RESTARTING", NDB_MGM_NODE_STATUS_RESTARTING },
  528.   { "SINGLE USER MODE", NDB_MGM_NODE_STATUS_SINGLEUSER }
  529. };
  531. const int no_of_status_values = (sizeof(status_values) / 
  532.  sizeof(ndb_mgm_status_atoi));
  534. extern "C"
  535. ndb_mgm_node_status
  536. ndb_mgm_match_node_status(const char * status)
  537. {
  538.   if(status == 0)
  539.     return NDB_MGM_NODE_STATUS_UNKNOWN;
  540.   
  541.   for(int i = 0; i<no_of_status_values; i++)
  542.     if(strcmp(status, status_values[i].str) == 0)
  543.       return status_values[i].value;
  545.   return NDB_MGM_NODE_STATUS_UNKNOWN;
  546. }
  548. extern "C"
  549. const char * 
  550. ndb_mgm_get_node_status_string(enum ndb_mgm_node_status status)
  551. {
  552.   int i;
  553.   for(i = 0; i<no_of_status_values; i++)
  554.     if(status_values[i].value == status)
  555.       return status_values[i].str;
  557.   for(i = 0; i<no_of_status_values; i++)
  558.     if(status_values[i].value == NDB_MGM_NODE_STATUS_UNKNOWN)
  559.       return status_values[i].str;
  560.   
  561.   return 0;
  562. }
  564. static int
  565. status_ackumulate(struct ndb_mgm_node_state * state,
  566.   const char * field,
  567.   const char * value)
  568. {
  569.   if(strcmp("type", field) == 0){
  570.     state->node_type = ndb_mgm_match_node_type(value);
  571.   } else if(strcmp("status", field) == 0){
  572.     state->node_status = ndb_mgm_match_node_status(value);
  573.   } else if(strcmp("startphase", field) == 0){
  574.     state->start_phase = atoi(value);
  575.   } else if(strcmp("dynamic_id", field) == 0){
  576.     state->dynamic_id = atoi(value);
  577.   } else if(strcmp("node_group", field) == 0){
  578.     state->node_group = atoi(value);
  579.   } else if(strcmp("version", field) == 0){
  580.     state->version = atoi(value);
  581.   } else if(strcmp("connect_count", field) == 0){
  582.     state->connect_count = atoi(value);    
  583.   } else if(strcmp("address", field) == 0){
  584.     strncpy(state->connect_address, value, sizeof(state->connect_address));
  585.     state->connect_address[sizeof(state->connect_address)-1]= 0;
  586.   } else {
  587.     ndbout_c("Unknown field: %s", field);
  588.   }
  589.   return 0;
  590. }
  592. /**
  593.  * Compare function for qsort() that sorts ndb_mgm_node_state in
  594.  * node_id order
  595.  */
  596. static int
  597. cmp_state(const void *_a, const void *_b) 
  598. {
  599.   struct ndb_mgm_node_state *a, *b;
  601.   a = (struct ndb_mgm_node_state *)_a;
  602.   b = (struct ndb_mgm_node_state *)_b;
  604.   if (a->node_id > b->node_id)
  605.     return 1;
  606.   return -1;
  607. }
  609. extern "C"
  610. struct ndb_mgm_cluster_state * 
  611. ndb_mgm_get_status(NdbMgmHandle handle)
  612. {
  613.   SET_ERROR(handle, NDB_MGM_NO_ERROR, "Executing: ndb_mgm_get_status");
  614.   CHECK_HANDLE(handle, NULL);
  615.   CHECK_CONNECTED(handle, NULL);
  617.   SocketOutputStream out(handle->socket);
  618.   SocketInputStream in(handle->socket, handle->read_timeout);
  620.   out.println("get status");
  621.   out.println("");
  623.   char buf[1024];
  624.   in.gets(buf, sizeof(buf));
  625.   if(buf[strlen(buf)-1] == 'n')
  626.     buf[strlen(buf)-1] = '';
  628.   if(strcmp("node status", buf) != 0) {
  629.     SET_ERROR(handle, NDB_MGM_ILLEGAL_NODE_STATUS, buf);
  630.     return NULL;
  631.   }
  633.   in.gets(buf, sizeof(buf));
  634.   if(buf[strlen(buf)-1] == 'n')
  635.     buf[strlen(buf)-1] = '';
  636.   
  637.   BaseString tmp(buf);
  638.   Vector<BaseString> split;
  639.   tmp.split(split, ":");
  640.   if(split.size() != 2){
  641.     return NULL;
  642.   }
  643.  
  644.   if(!(split[0].trim() == "nodes")){
  645.     return NULL;
  646.   }
  648.   const int noOfNodes = atoi(split[1].c_str());
  650.   ndb_mgm_cluster_state *state = (ndb_mgm_cluster_state*)
  651.     malloc(sizeof(ndb_mgm_cluster_state)+
  652.    noOfNodes*(sizeof(ndb_mgm_node_state)+sizeof("000.000.000.000#")));
  654.   state->hostname= 0;
  655.   state->no_of_nodes= noOfNodes;
  656.   ndb_mgm_node_state * ptr = &state->node_states[0];
  657.   int nodeId = 0;
  658.   int i;
  659.   for (i= 0; i < noOfNodes; i++) {
  660.     state->node_states[i].connect_address[0]= 0;
  661.   }
  662.   i = -1; ptr--;
  663.   for(; i<noOfNodes; ){
  664.     in.gets(buf, sizeof(buf));
  665.     tmp.assign(buf);
  667.     if(tmp.trim() == ""){
  668.       break;
  669.     }
  670.     
  671.     Vector<BaseString> split;
  672.     tmp.split(split, ":.", 4);
  673.     if(split.size() != 4)
  674.       break;
  675.     
  676.     const int id = atoi(split[1].c_str());
  677.     if(id != nodeId){
  678.       ptr++;
  679.       i++;
  680.       nodeId = id;
  681.       ptr->node_id = id;
  682.     }
  684.     split[3].trim(" tn");
  686.     if(status_ackumulate(ptr,split[2].c_str(), split[3].c_str()) != 0) {
  687.       break;
  688.     }
  689.   }
  691.   if(i+1 != noOfNodes){
  692.     free(state);
  693.     return NULL;
  694.   }
  696.   qsort(state->node_states, state->no_of_nodes, sizeof(state->node_states[0]),
  697. cmp_state);
  698.   return state;
  699. }
  701. extern "C"
  702. int 
  703. ndb_mgm_enter_single_user(NdbMgmHandle handle,
  704.   unsigned int nodeId,
  705.   struct ndb_mgm_reply* /*reply*/) 
  706. {
  707.   SET_ERROR(handle, NDB_MGM_NO_ERROR, "Executing: ndb_mgm_enter_single_user");
  708.   const ParserRow<ParserDummy> enter_single_reply[] = {
  709.     MGM_CMD("enter single user reply", NULL, ""),
  710.     MGM_ARG("result", String, Mandatory, "Error message"),
  711.     MGM_END()
  712.   };
  713.   CHECK_HANDLE(handle, -1);
  714.   CHECK_CONNECTED(handle, -1);
  716.   Properties args;
  717.   args.put("nodeId", nodeId);
  718.   const Properties *reply;
  719.   reply = ndb_mgm_call(handle, enter_single_reply, "enter single user", &args);
  720.   CHECK_REPLY(reply, -1);
  722.   BaseString result;
  723.   reply->get("result", result);
  724.   if(strcmp(result.c_str(), "Ok") != 0) {
  725.     SET_ERROR(handle, NDB_MGM_COULD_NOT_ENTER_SINGLE_USER_MODE, 
  726.       result.c_str());
  727.     delete reply;
  728.     return -1;
  729.   }
  731.   delete reply;
  732.   return 0;
  733. }
  736. extern "C"
  737. int 
  738. ndb_mgm_exit_single_user(NdbMgmHandle handle, struct ndb_mgm_reply* /*reply*/) 
  739. {
  740.   SET_ERROR(handle, NDB_MGM_NO_ERROR, "Executing: ndb_mgm_exit_single_user");
  741.   const ParserRow<ParserDummy> exit_single_reply[] = {
  742.     MGM_CMD("exit single user reply", NULL, ""),
  743.     MGM_ARG("result", String, Mandatory, "Error message"),
  744.     MGM_END()
  745.   };
  746.   CHECK_HANDLE(handle, -1);
  747.   CHECK_CONNECTED(handle, -1);
  749.   const Properties *reply;
  750.   reply = ndb_mgm_call(handle, exit_single_reply, "exit single user", 0);
  751.   CHECK_REPLY(reply, -1);
  753.   const char * buf;
  754.   reply->get("result", &buf);
  755.   if(strcmp(buf,"Ok")!=0) {
  756.     SET_ERROR(handle, NDB_MGM_COULD_NOT_EXIT_SINGLE_USER_MODE, buf);
  757.     delete reply;    
  758.     return -1;
  759.   }
  761.   delete reply;
  762.   return 0;
  763. }
  765. extern "C"
  766. int 
  767. ndb_mgm_stop(NdbMgmHandle handle, int no_of_nodes, const int * node_list)
  768. {
  769.   SET_ERROR(handle, NDB_MGM_NO_ERROR, "Executing: ndb_mgm_stop");
  770.   return ndb_mgm_stop2(handle, no_of_nodes, node_list, 0);
  771. }
  774. extern "C"
  775. int 
  776. ndb_mgm_stop2(NdbMgmHandle handle, int no_of_nodes, const int * node_list,
  777.       int abort)
  778. {
  779.   SET_ERROR(handle, NDB_MGM_NO_ERROR, "Executing: ndb_mgm_stop2");
  780.   const ParserRow<ParserDummy> stop_reply[] = {
  781.     MGM_CMD("stop reply", NULL, ""),
  782.     MGM_ARG("stopped", Int, Optional, "No of stopped nodes"),
  783.     MGM_ARG("result", String, Mandatory, "Error message"),
  784.     MGM_END()
  785.   };
  786.   CHECK_HANDLE(handle, -1);
  787.   CHECK_CONNECTED(handle, -1);
  789.   if(no_of_nodes < 0){
  790.     SET_ERROR(handle, NDB_MGM_ILLEGAL_NUMBER_OF_NODES, 
  791.       "Negative number of nodes requested to stop");
  792.     return -1;
  793.   }
  795.   Uint32 stoppedNoOfNodes = 0;
  796.   if(no_of_nodes == 0){
  797.     /**
  798.      * All database nodes should be stopped
  799.      */
  800.     Properties args;
  801.     args.put("abort", abort);
  802.     const Properties *reply;
  803.     reply = ndb_mgm_call(handle, stop_reply, "stop all", &args);
  804.     CHECK_REPLY(reply, -1);
  806.     if(!reply->get("stopped", &stoppedNoOfNodes)){
  807.       SET_ERROR(handle, NDB_MGM_STOP_FAILED, 
  808. "Could not get number of stopped nodes from mgm server");
  809.       delete reply;
  810.       return -1;
  811.     }
  812.     BaseString result;
  813.     reply->get("result", result);
  814.     if(strcmp(result.c_str(), "Ok") != 0) {
  815.       SET_ERROR(handle, NDB_MGM_STOP_FAILED, result.c_str());
  816.       delete reply;
  817.       return -1;
  818.     }
  819.     delete reply;
  820.     return stoppedNoOfNodes;
  821.   }
  823.   /**
  824.    * A list of database nodes should be stopped
  825.    */
  826.   Properties args;
  828.   BaseString node_list_str;
  829.   node_list_str.assfmt("%d", node_list[0]);
  830.   for(int node = 1; node < no_of_nodes; node++)
  831.     node_list_str.appfmt(" %d", node_list[node]);
  832.   
  833.   args.put("node", node_list_str.c_str());
  834.   args.put("abort", abort);
  836.   const Properties *reply;
  837.   reply = ndb_mgm_call(handle, stop_reply, "stop", &args);
  838.   CHECK_REPLY(reply, stoppedNoOfNodes);
  839.   if(!reply->get("stopped", &stoppedNoOfNodes)){
  840.     SET_ERROR(handle, NDB_MGM_STOP_FAILED, 
  841.       "Could not get number of stopped nodes from mgm server");
  842.     delete reply;
  843.     return -1;
  844.   }
  845.   BaseString result;
  846.   reply->get("result", result);
  847.   if(strcmp(result.c_str(), "Ok") != 0) {
  848.     SET_ERROR(handle, NDB_MGM_STOP_FAILED, result.c_str());
  849.     delete reply;
  850.     return -1;
  851.   }
  852.   delete reply;
  853.   return stoppedNoOfNodes;
  854. }
  856. extern "C"
  857. int
  858. ndb_mgm_restart2(NdbMgmHandle handle, int no_of_nodes, const int * node_list,
  859.  int initial, int nostart, int abort)
  860. {
  861.   SET_ERROR(handle, NDB_MGM_NO_ERROR, "Executing: ndb_mgm_restart2");
  862.   Uint32 restarted = 0;
  863.   const ParserRow<ParserDummy> restart_reply[] = {
  864.     MGM_CMD("restart reply", NULL, ""),
  865.     MGM_ARG("result", String, Mandatory, "Error message"),
  866.     MGM_ARG("restarted", Int, Optional, "No of restarted nodes"),
  867.     MGM_END()
  868.   };
  869.   CHECK_HANDLE(handle, -1);
  870.   CHECK_CONNECTED(handle, -1);
  871.   
  872.   if(no_of_nodes < 0){
  873.     SET_ERROR(handle, NDB_MGM_RESTART_FAILED, 
  874.       "Restart requested of negative number of nodes");
  875.     return -1;
  876.   }
  877.   
  878.   if(no_of_nodes == 0) {
  879.     Properties args;    
  880.     args.put("abort", abort);
  881.     args.put("initialstart", initial);
  882.     args.put("nostart", nostart);
  883.     const Properties *reply;
  884.     const int timeout = handle->read_timeout;
  885.     handle->read_timeout= 5*60*1000; // 5 minutes
  886.     reply = ndb_mgm_call(handle, restart_reply, "restart all", &args);
  887.     handle->read_timeout= timeout;
  888.     CHECK_REPLY(reply, -1);
  890.     BaseString result;
  891.     reply->get("result", result);
  892.     if(strcmp(result.c_str(), "Ok") != 0) {
  893.       SET_ERROR(handle, NDB_MGM_RESTART_FAILED, result.c_str());
  894.       delete reply;
  895.       return -1;
  896.     }
  897.     if(!reply->get("restarted", &restarted)){
  898.       SET_ERROR(handle, NDB_MGM_RESTART_FAILED, 
  899. "Could not get restarted number of nodes from mgm server");
  900.       delete reply;
  901.       return -1;
  902.     }
  903.     delete reply;
  904.     return restarted;
  905.   }      
  907.   BaseString node_list_str;
  908.   node_list_str.assfmt("%d", node_list[0]);
  909.   for(int node = 1; node < no_of_nodes; node++)
  910.     node_list_str.appfmt(" %d", node_list[node]);
  912.   Properties args;
  913.   
  914.   args.put("node", node_list_str.c_str());
  915.   args.put("abort", abort);
  916.   args.put("initialstart", initial);
  917.   args.put("nostart", nostart);
  919.   const Properties *reply;
  920.   const int timeout = handle->read_timeout;
  921.   handle->read_timeout= 5*60*1000; // 5 minutes
  922.   reply = ndb_mgm_call(handle, restart_reply, "restart node", &args);
  923.   handle->read_timeout= timeout;
  924.   if(reply != NULL) {
  925.     BaseString result;
  926.     reply->get("result", result);
  927.     if(strcmp(result.c_str(), "Ok") != 0) {
  928.       SET_ERROR(handle, NDB_MGM_RESTART_FAILED, result.c_str());
  929.       delete reply;
  930.       return -1;
  931.     }
  932.     reply->get("restarted", &restarted);
  933.     delete reply;
  934.   } 
  935.   
  936.   return restarted;
  937. }
  939. extern "C"
  940. int
  941. ndb_mgm_restart(NdbMgmHandle handle, int no_of_nodes, const int *node_list) 
  942. {
  943.   SET_ERROR(handle, NDB_MGM_NO_ERROR, "Executing: ndb_mgm_restart");
  944.   return ndb_mgm_restart2(handle, no_of_nodes, node_list, 0, 0, 0);
  945. }
  947. static const char *clusterlog_level_names[]=
  948.   { "enabled", "debug", "info", "warning", "error", "critical", "alert" };
  950. struct ndb_mgm_clusterlog_levels 
  951. {
  952.   const char* name;
  953.   enum ndb_mgm_clusterlog_level level;
  954. } clusterlog_levels[] = {
  955.   { clusterlog_level_names[0], NDB_MGM_CLUSTERLOG_ON },
  956.   { clusterlog_level_names[1], NDB_MGM_CLUSTERLOG_DEBUG },
  957.   { clusterlog_level_names[2], NDB_MGM_CLUSTERLOG_INFO },
  958.   { clusterlog_level_names[3], NDB_MGM_CLUSTERLOG_WARNING },
  959.   { clusterlog_level_names[4], NDB_MGM_CLUSTERLOG_ERROR },
  960.   { clusterlog_level_names[5], NDB_MGM_CLUSTERLOG_CRITICAL },
  961.   { clusterlog_level_names[6], NDB_MGM_CLUSTERLOG_ALERT },
  962.   { "all",                     NDB_MGM_CLUSTERLOG_ALL },
  963.   { 0,                         NDB_MGM_ILLEGAL_CLUSTERLOG_LEVEL },
  964. };
  966. extern "C"
  967. ndb_mgm_clusterlog_level
  968. ndb_mgm_match_clusterlog_level(const char * name)
  969. {
  970.   if(name == 0)
  971.     return NDB_MGM_ILLEGAL_CLUSTERLOG_LEVEL;
  972.   
  973.   for(int i = 0; clusterlog_levels[i].name !=0 ; i++)
  974.     if(strcasecmp(name, clusterlog_levels[i].name) == 0)
  975.       return clusterlog_levels[i].level;
  977.   return NDB_MGM_ILLEGAL_CLUSTERLOG_LEVEL;
  978. }
  980. extern "C"
  981. const char * 
  982. ndb_mgm_get_clusterlog_level_string(enum ndb_mgm_clusterlog_level level)
  983. {
  984.   int i= (int)level;
  985.   if (i >= 0 && i < (int)NDB_MGM_CLUSTERLOG_ALL)
  986.     return clusterlog_level_names[i];
  987.   for(i = (int)NDB_MGM_CLUSTERLOG_ALL; clusterlog_levels[i].name != 0; i++)
  988.     if(clusterlog_levels[i].level == level)
  989.       return clusterlog_levels[i].name;
  990.   return 0;
  991. }
  993. extern "C"
  994. unsigned int *
  995. ndb_mgm_get_logfilter(NdbMgmHandle handle) 
  996. {
  997.   SET_ERROR(handle, NDB_MGM_NO_ERROR, "Executing: ndb_mgm_get_logfilter");
  998.   static Uint32 enabled[(int)NDB_MGM_CLUSTERLOG_ALL] = {0,0,0,0,0,0,0};
  999.   const ParserRow<ParserDummy> getinfo_reply[] = {
  1000.     MGM_CMD("clusterlog", NULL, ""),
  1001.     MGM_ARG(clusterlog_level_names[0], Int, Mandatory, ""),
  1002.     MGM_ARG(clusterlog_level_names[1], Int, Mandatory, ""),
  1003.     MGM_ARG(clusterlog_level_names[2], Int, Mandatory, ""),
  1004.     MGM_ARG(clusterlog_level_names[3], Int, Mandatory, ""),
  1005.     MGM_ARG(clusterlog_level_names[4], Int, Mandatory, ""),
  1006.     MGM_ARG(clusterlog_level_names[5], Int, Mandatory, ""),
  1007.     MGM_ARG(clusterlog_level_names[6], Int, Mandatory, ""),
  1008.   };
  1009.   CHECK_HANDLE(handle, NULL);
  1010.   CHECK_CONNECTED(handle, NULL);
  1012.   Properties args;
  1013.   const Properties *reply;
  1014.   reply = ndb_mgm_call(handle, getinfo_reply, "get info clusterlog", &args);
  1015.   CHECK_REPLY(reply, NULL);
  1016.   
  1017.   for(int i=0; i < (int)NDB_MGM_CLUSTERLOG_ALL; i++) {
  1018.     reply->get(clusterlog_level_names[i], &enabled[i]);
  1019.   }
  1020.   return enabled;
  1021. }
  1023. extern "C"
  1024. int 
  1025. ndb_mgm_filter_clusterlog(NdbMgmHandle handle, 
  1026.   enum ndb_mgm_clusterlog_level level,
  1027.   int enable,
  1028.   struct ndb_mgm_reply* /*reply*/) 
  1029. {
  1030.   SET_ERROR(handle, NDB_MGM_NO_ERROR, "Executing: ndb_mgm_filter_clusterlog");
  1031.   const ParserRow<ParserDummy> filter_reply[] = {
  1032.     MGM_CMD("set logfilter reply", NULL, ""),
  1033.     MGM_ARG("result", String, Mandatory, "Error message"),
  1034.     MGM_END()
  1035.   };
  1036.   int retval = -1;
  1037.   CHECK_HANDLE(handle, -1);
  1038.   CHECK_CONNECTED(handle, -1);
  1040.   Properties args;
  1041.   args.put("level", level);
  1042.   args.put("enable", enable);
  1043.   
  1044.   const Properties *reply;
  1045.   reply = ndb_mgm_call(handle, filter_reply, "set logfilter", &args);
  1046.   CHECK_REPLY(reply, retval);
  1048.   BaseString result;
  1049.   reply->get("result", result);
  1051.   if (strcmp(result.c_str(), "1") == 0)
  1052.     retval = 1;
  1053.   else if (strcmp(result.c_str(), "0") == 0)
  1054.     retval = 0;
  1055.   else
  1056.   {
  1057.     SET_ERROR(handle, EINVAL, result.c_str());
  1058.   }
  1059.   delete reply;
  1060.   return retval;
  1061. }
  1063. struct ndb_mgm_event_categories 
  1064. {
  1065.   const char* name;
  1066.   enum ndb_mgm_event_category category;
  1067. } categories[] = {
  1068.   { "STARTUP", NDB_MGM_EVENT_CATEGORY_STARTUP },
  1069.   { "SHUTDOWN", NDB_MGM_EVENT_CATEGORY_SHUTDOWN },
  1070.   { "STATISTICS", NDB_MGM_EVENT_CATEGORY_STATISTIC },
  1071.   { "NODERESTART", NDB_MGM_EVENT_CATEGORY_NODE_RESTART },
  1072.   { "CONNECTION", NDB_MGM_EVENT_CATEGORY_CONNECTION },
  1073.   { "CHECKPOINT", NDB_MGM_EVENT_CATEGORY_CHECKPOINT },
  1074.   { "DEBUG", NDB_MGM_EVENT_CATEGORY_DEBUG },
  1075.   { "INFO", NDB_MGM_EVENT_CATEGORY_INFO },
  1076.   { "ERROR", NDB_MGM_EVENT_CATEGORY_ERROR },
  1077.   { "GREP", NDB_MGM_EVENT_CATEGORY_GREP },
  1078.   { "BACKUP", NDB_MGM_EVENT_CATEGORY_BACKUP },
  1079.   { 0, NDB_MGM_ILLEGAL_EVENT_CATEGORY }
  1080. };
  1082. extern "C"
  1083. ndb_mgm_event_category
  1084. ndb_mgm_match_event_category(const char * status)
  1085. {
  1086.   if(status == 0)
  1087.     return NDB_MGM_ILLEGAL_EVENT_CATEGORY;
  1088.   
  1089.   for(int i = 0; categories[i].name !=0 ; i++)
  1090.     if(strcmp(status, categories[i].name) == 0)
  1091.       return categories[i].category;
  1093.   return NDB_MGM_ILLEGAL_EVENT_CATEGORY;
  1094. }
  1096. extern "C"
  1097. const char * 
  1098. ndb_mgm_get_event_category_string(enum ndb_mgm_event_category status)
  1099. {
  1100.   int i;
  1101.   for(i = 0; categories[i].name != 0; i++)
  1102.     if(categories[i].category == status)
  1103.       return categories[i].name;
  1104.   
  1105.   return 0;
  1106. }
  1108. extern "C"
  1109. int 
  1110. ndb_mgm_set_loglevel_clusterlog(NdbMgmHandle handle, int nodeId,
  1111. enum ndb_mgm_event_category cat,
  1112. int level,
  1113. struct ndb_mgm_reply* /*reply*/) 
  1114. {
  1115.   SET_ERROR(handle, NDB_MGM_NO_ERROR, 
  1116.     "Executing: ndb_mgm_set_loglevel_clusterlog");
  1117.   const ParserRow<ParserDummy> clusterlog_reply[] = {
  1118.     MGM_CMD("set cluster loglevel reply", NULL, ""),
  1119.     MGM_ARG("result", String, Mandatory, "Error message"),
  1120.     MGM_END()
  1121.   };
  1122.   CHECK_HANDLE(handle, -1);
  1123.   CHECK_CONNECTED(handle, -1);
  1125.   Properties args;
  1126.   args.put("node", nodeId);
  1127.   args.put("category", cat);
  1128.   args.put("level", level);
  1129.   
  1130.   const Properties *reply;
  1131.   reply = ndb_mgm_call(handle, clusterlog_reply, 
  1132.        "set cluster loglevel", &args);
  1133.   CHECK_REPLY(reply, -1);
  1134.   
  1135.   DBUG_ENTER("ndb_mgm_set_loglevel_clusterlog");
  1136.   DBUG_PRINT("enter",("node=%d, category=%d, level=%d", nodeId, cat, level));
  1138.   BaseString result;
  1139.   reply->get("result", result);
  1140.   if(strcmp(result.c_str(), "Ok") != 0) {
  1141.     SET_ERROR(handle, EINVAL, result.c_str());
  1142.     delete reply;
  1143.     DBUG_RETURN(-1);
  1144.   }
  1145.   delete reply;
  1146.   DBUG_RETURN(0);
  1147. }
  1149. extern "C"
  1150. int 
  1151. ndb_mgm_set_loglevel_node(NdbMgmHandle handle, int nodeId,
  1152.   enum ndb_mgm_event_category category,
  1153.   int level,
  1154.   struct ndb_mgm_reply* /*reply*/) 
  1155. {
  1156.   SET_ERROR(handle, NDB_MGM_NO_ERROR, "Executing: ndb_mgm_set_loglevel_node");
  1157.   const ParserRow<ParserDummy> loglevel_reply[] = {
  1158.     MGM_CMD("set loglevel reply", NULL, ""),
  1159.     MGM_ARG("result", String, Mandatory, "Error message"),
  1160.     MGM_END()
  1161.   };
  1162.   CHECK_HANDLE(handle, -1);
  1163.   CHECK_CONNECTED(handle, -1);
  1165.   Properties args;
  1166.   args.put("node", nodeId);
  1167.   args.put("category", category);
  1168.   args.put("level", level);
  1169.   const Properties *reply;
  1170.   reply = ndb_mgm_call(handle, loglevel_reply, "set loglevel", &args);
  1171.   CHECK_REPLY(reply, -1);
  1173.   BaseString result;
  1174.   reply->get("result", result);
  1175.   if(strcmp(result.c_str(), "Ok") != 0) {
  1176.     SET_ERROR(handle, EINVAL, result.c_str());
  1177.     delete reply;
  1178.     return -1;
  1179.   }
  1181.   delete reply;
  1182.   return 0;
  1183. }
  1185. extern "C"
  1186. int
  1187. ndb_mgm_listen_event(NdbMgmHandle handle, int filter[])
  1188. {
  1189.   SET_ERROR(handle, NDB_MGM_NO_ERROR, "Executing: ndb_mgm_listen_event");
  1190.   const ParserRow<ParserDummy> stat_reply[] = {
  1191.     MGM_CMD("listen event", NULL, ""),
  1192.     MGM_ARG("result", Int, Mandatory, "Error message"),
  1193.     MGM_ARG("msg", String, Optional, "Error message"),
  1194.     MGM_END()
  1195.   };
  1196.   CHECK_HANDLE(handle, -1);
  1197.   
  1198.   const char *hostname= ndb_mgm_get_connected_host(handle);
  1199.   int port= ndb_mgm_get_connected_port(handle);
  1200.   SocketClient s(hostname, port);
  1201.   const NDB_SOCKET_TYPE sockfd = s.connect();
  1202.   if (sockfd == NDB_INVALID_SOCKET) {
  1203.     setError(handle, NDB_MGM_COULD_NOT_CONNECT_TO_SOCKET, __LINE__,
  1204.      "Unable to connect to");
  1205.     return -1;
  1206.   }
  1208.   Properties args;
  1209.   {
  1210.     BaseString tmp;
  1211.     for(int i = 0; filter[i] != 0; i += 2){
  1212.       tmp.appfmt("%d=%d ", filter[i+1], filter[i]);
  1213.     }
  1214.     args.put("filter", tmp.c_str());
  1215.   }
  1216.   
  1217.   int tmp = handle->socket;
  1218.   handle->socket = sockfd;
  1219.   
  1220.   const Properties *reply;
  1221.   reply = ndb_mgm_call(handle, stat_reply, "listen event", &args);
  1222.   
  1223.   handle->socket = tmp;
  1224.   
  1225.   CHECK_REPLY(reply, -1);
  1226.   return sockfd;
  1227. }
  1229. extern "C"
  1230. int 
  1231. ndb_mgm_get_stat_port(NdbMgmHandle handle, struct ndb_mgm_reply* /*reply*/)
  1232. {
  1233.   SET_ERROR(handle, NDB_MGM_NO_ERROR, "Executing: ndb_mgm_get_stat_port");
  1234.   const ParserRow<ParserDummy> stat_reply[] = {
  1235.     MGM_CMD("error", NULL, ""),
  1236.     MGM_ARG("result", String, Mandatory, "Error message"),
  1237.     MGM_CMD("get statport reply", NULL, ""),
  1238.     MGM_ARG("tcpport", Int, Mandatory, "TCP port for statistics"),
  1239.     MGM_END()
  1240.   };
  1241.   CHECK_HANDLE(handle, -1);
  1242.   CHECK_CONNECTED(handle, -1);
  1243.   
  1244.   Properties args;
  1245.   const Properties *reply;
  1246.   reply = ndb_mgm_call(handle, stat_reply, "get statport", &args);
  1247.   CHECK_REPLY(reply, -1);
  1249.   Uint32 port;
  1250.   reply->get("tcpport", &port);
  1252.   delete reply;
  1253.   return port;
  1254. }
  1256. extern "C"
  1257. int 
  1258. ndb_mgm_dump_state(NdbMgmHandle handle, int nodeId, int* _args,
  1259.    int _num_args, struct ndb_mgm_reply* /* reply */) 
  1260. {
  1261.   SET_ERROR(handle, NDB_MGM_NO_ERROR, "Executing: ndb_mgm_dump_state");
  1262.   const ParserRow<ParserDummy> dump_state_reply[] = {
  1263.     MGM_CMD("dump state reply", NULL, ""),
  1264.     MGM_ARG("result", String, Mandatory, "Error message"),
  1265.     MGM_END()
  1266.   };
  1267.   CHECK_HANDLE(handle, -1);
  1268.   CHECK_CONNECTED(handle, -1);
  1270.   char buf[256];
  1271.   buf[0] = 0;
  1272.   for (int i = 0; i < _num_args; i++){
  1273.     unsigned n = strlen(buf);
  1274.     if (n + 20 > sizeof(buf)) {
  1275.       SET_ERROR(handle, NDB_MGM_USAGE_ERROR, "arguments too long");
  1276.       return -1;
  1277.     }
  1278.     sprintf(buf + n, "%s%d", i ? " " : "", _args[i]);
  1279.   }
  1281.   Properties args;
  1282.   args.put("node", nodeId);
  1283.   args.put("args", buf);
  1285.   const Properties *prop;
  1286.   prop = ndb_mgm_call(handle, dump_state_reply, "dump state", &args);
  1287.   CHECK_REPLY(prop, -1);
  1289.   BaseString result;
  1290.   prop->get("result", result);
  1291.   if(strcmp(result.c_str(), "Ok") != 0) {
  1292.     SET_ERROR(handle, EINVAL, result.c_str());
  1293.     delete prop;
  1294.     return -1;
  1295.   }
  1297.   delete prop;
  1298.   return 0;
  1299. }
  1301. extern "C"
  1302. int 
  1303. ndb_mgm_start_signallog(NdbMgmHandle handle, int nodeId, 
  1304. struct ndb_mgm_reply* reply) 
  1305. {
  1306.   SET_ERROR(handle, NDB_MGM_NO_ERROR, "Executing: ndb_mgm_start_signallog");
  1307.   const ParserRow<ParserDummy> start_signallog_reply[] = {
  1308.     MGM_CMD("start signallog reply", NULL, ""),
  1309.     MGM_ARG("result", String, Mandatory, "Error message"),
  1310.     MGM_END()
  1311.   };
  1312.   int retval = -1;
  1313.   CHECK_HANDLE(handle, -1);
  1314.   CHECK_CONNECTED(handle, -1);
  1316.   Properties args;
  1317.   args.put("node", nodeId);
  1319.   const Properties *prop;
  1320.   prop = ndb_mgm_call(handle,
  1321.        start_signallog_reply,
  1322.        "start signallog",
  1323.        &args);
  1325.   if(prop != NULL) {
  1326.     BaseString result;
  1327.     prop->get("result", result);
  1328.     if(strcmp(result.c_str(), "Ok") == 0) {
  1329.       retval = 0;
  1330.     } else {
  1331.       SET_ERROR(handle, EINVAL, result.c_str());
  1332.       retval = -1;
  1333.     }
  1334.     delete prop;
  1335.   }
  1337.   return retval;
  1338. }
  1340. extern "C"
  1341. int 
  1342. ndb_mgm_stop_signallog(NdbMgmHandle handle, int nodeId,
  1343.        struct ndb_mgm_reply* reply) 
  1344. {
  1345.   SET_ERROR(handle, NDB_MGM_NO_ERROR, "Executing: ndb_mgm_stop_signallog");
  1346.   const ParserRow<ParserDummy> stop_signallog_reply[] = {
  1347.     MGM_CMD("stop signallog reply", NULL, ""),
  1348.     MGM_ARG("result", String, Mandatory, "Error message"),
  1349.     MGM_END()
  1350.   };
  1351.   int retval = -1;
  1352.   CHECK_HANDLE(handle, -1);
  1353.   CHECK_CONNECTED(handle, -1);
  1354.   
  1355.   Properties args;
  1356.   args.put("node", nodeId);
  1358.   const Properties *prop;
  1359.   prop = ndb_mgm_call(handle, stop_signallog_reply, "stop signallog", &args);
  1361.   if(prop != NULL) {
  1362.     BaseString result;
  1363.     prop->get("result", result);
  1364.     if(strcmp(result.c_str(), "Ok") == 0) {
  1365.       retval = 0;
  1366.     } else {
  1367.       SET_ERROR(handle, EINVAL, result.c_str());
  1368.       retval = -1;
  1369.     }
  1370.     delete prop;
  1371.   }
  1373.   return retval;
  1374. }
  1376. struct ndb_mgm_signal_log_modes 
  1377. {
  1378.   const char* name;
  1379.   enum ndb_mgm_signal_log_mode mode;
  1380. };
  1382. extern "C"
  1383. int 
  1384. ndb_mgm_log_signals(NdbMgmHandle handle, int nodeId, 
  1385.     enum ndb_mgm_signal_log_mode mode, 
  1386.     const char* blockNames,
  1387.     struct ndb_mgm_reply* reply) 
  1388. {
  1389.   SET_ERROR(handle, NDB_MGM_NO_ERROR, "Executing: ndb_mgm_log_signals");
  1390.   const ParserRow<ParserDummy> stop_signallog_reply[] = {
  1391.     MGM_CMD("log signals reply", NULL, ""),
  1392.     MGM_ARG("result", String, Mandatory, "Error message"),
  1393.     MGM_END()
  1394.   };
  1395.   int retval = -1;
  1396.   CHECK_HANDLE(handle, -1);
  1397.   CHECK_CONNECTED(handle, -1);
  1399.   Properties args;
  1400.   args.put("node", nodeId);
  1401.   args.put("blocks", blockNames);
  1403.   switch(mode) {
  1404.   case NDB_MGM_SIGNAL_LOG_MODE_IN:
  1405.     args.put("in", (Uint32)1);
  1406.     args.put("out", (Uint32)0);
  1407.     break;
  1408.   case NDB_MGM_SIGNAL_LOG_MODE_OUT:
  1409.     args.put("in", (Uint32)0);
  1410.     args.put("out", (Uint32)1);
  1411.     break;
  1412.   case NDB_MGM_SIGNAL_LOG_MODE_INOUT:
  1413.     args.put("in", (Uint32)1);
  1414.     args.put("out", (Uint32)1);
  1415.     break;
  1416.   case NDB_MGM_SIGNAL_LOG_MODE_OFF:
  1417.     args.put("in", (Uint32)0);
  1418.     args.put("out", (Uint32)0);
  1419.     break;
  1420.   }
  1422.   const Properties *prop;
  1423.   prop = ndb_mgm_call(handle, stop_signallog_reply, "log signals", &args);
  1425.   if(prop != NULL) {
  1426.     BaseString result;
  1427.     prop->get("result", result);
  1428.     if(strcmp(result.c_str(), "Ok") == 0) {
  1429.       retval = 0;
  1430.     } else {
  1431.       SET_ERROR(handle, EINVAL, result.c_str());
  1432.       retval = -1;
  1433.     }
  1434.     delete prop;
  1435.   }
  1437.   return retval;
  1438. }
  1440. extern "C"
  1441. int 
  1442. ndb_mgm_set_trace(NdbMgmHandle handle, int nodeId, int traceNumber,
  1443.   struct ndb_mgm_reply* reply) 
  1444. {
  1445.   SET_ERROR(handle, NDB_MGM_NO_ERROR, "Executing: ndb_mgm_set_trace");
  1446.   const ParserRow<ParserDummy> set_trace_reply[] = {
  1447.     MGM_CMD("set trace reply", NULL, ""),
  1448.     MGM_ARG("result", String, Mandatory, "Error message"),
  1449.     MGM_END()
  1450.   };
  1451.   int retval = -1;
  1452.   CHECK_HANDLE(handle, -1);
  1453.   CHECK_CONNECTED(handle, -1);
  1455.   Properties args;
  1456.   args.put("node", nodeId);
  1457.   args.put("trace", traceNumber);
  1459.   const Properties *prop;
  1460.   prop = ndb_mgm_call(handle, set_trace_reply, "set trace", &args);
  1462.   if(prop != NULL) {
  1463.     BaseString result;
  1464.     prop->get("result", result);
  1465.     if(strcmp(result.c_str(), "Ok") == 0) {
  1466.       retval = 0;
  1467.     } else {
  1468.       SET_ERROR(handle, EINVAL, result.c_str());
  1469.       retval = -1;
  1470.     }
  1471.     delete prop;
  1472.   }
  1474.   return retval;
  1475. }
  1477. extern "C"
  1478. int 
  1479. ndb_mgm_insert_error(NdbMgmHandle handle, int nodeId, int errorCode,
  1480.      struct ndb_mgm_reply* reply) 
  1481. {
  1482.   SET_ERROR(handle, NDB_MGM_NO_ERROR, "Executing: ndb_mgm_insert_error");
  1483.   const ParserRow<ParserDummy> insert_error_reply[] = {
  1484.     MGM_CMD("insert error reply", NULL, ""),
  1485.     MGM_ARG("result", String, Mandatory, "Error message"),
  1486.     MGM_END()
  1487.   };
  1488.   int retval = -1;
  1489.   CHECK_HANDLE(handle, -1);
  1490.   CHECK_CONNECTED(handle, -1);
  1492.   Properties args;
  1493.   args.put("node", nodeId);
  1494.   args.put("error", errorCode);
  1496.   const Properties *prop;
  1497.   prop = ndb_mgm_call(handle, insert_error_reply, "insert error", &args);
  1499.   if(prop != NULL) {
  1500.     BaseString result;
  1501.     prop->get("result", result);
  1502.     if(strcmp(result.c_str(), "Ok") == 0) {
  1503.       retval = 0;
  1504.     } else {
  1505.       SET_ERROR(handle, EINVAL, result.c_str());
  1506.       retval = -1;
  1507.     }
  1508.     delete prop;
  1509.   }
  1511.   return retval;
  1512. }
  1514. extern "C"
  1515. int 
  1516. ndb_mgm_start(NdbMgmHandle handle, int no_of_nodes, const int * node_list)
  1517. {
  1518.   SET_ERROR(handle, NDB_MGM_NO_ERROR, "Executing: ndb_mgm_start");
  1519.   const ParserRow<ParserDummy> start_reply[] = {
  1520.     MGM_CMD("start reply", NULL, ""),
  1521.     MGM_ARG("started", Int, Optional, "No of started nodes"),
  1522.     MGM_ARG("result", String, Mandatory, "Error message"),
  1523.     MGM_END()
  1524.   };
  1525.   int started = 0;
  1526.   CHECK_HANDLE(handle, -1);
  1527.   CHECK_CONNECTED(handle, -1);
  1529.   if(no_of_nodes < 0){
  1530.     SET_ERROR(handle, EINVAL, "");
  1531.     return -1;
  1532.   }
  1534.   if(no_of_nodes == 0){
  1535.     Properties args;
  1536.     const Properties *reply;
  1537.     reply = ndb_mgm_call(handle, start_reply, "start all", &args);
  1538.     CHECK_REPLY(reply, -1);
  1540.     Uint32 count = 0;
  1541.     if(!reply->get("started", &count)){
  1542.       delete reply;
  1543.       return -1;
  1544.     }
  1545.     delete reply;
  1546.     return count;
  1547.   }
  1549.   for(int node = 0; node < no_of_nodes; node++) {
  1550.     Properties args;
  1551.     args.put("node", node_list[node]);
  1553.     const Properties *reply;
  1554.     reply = ndb_mgm_call(handle, start_reply, "start", &args);
  1556.     if(reply != NULL) {
  1557.       BaseString result;
  1558.       reply->get("result", result);
  1559.       if(strcmp(result.c_str(), "Ok") == 0) {
  1560. started++;
  1561.       } else {
  1562. SET_ERROR(handle, EINVAL, result.c_str());
  1563. delete reply;
  1564. return -1;
  1565.       }
  1566.     }
  1567.     delete reply;
  1568.   }
  1570.   return started;
  1571. }
  1573. /*****************************************************************************
  1574.  * Backup
  1575.  *****************************************************************************/
  1576. extern "C"
  1577. int 
  1578. ndb_mgm_start_backup(NdbMgmHandle handle, int wait_completed,
  1579.      unsigned int* _backup_id,
  1580.      struct ndb_mgm_reply* /*reply*/) 
  1581. {
  1582.   SET_ERROR(handle, NDB_MGM_NO_ERROR, "Executing: ndb_mgm_start_backup");
  1583.   const ParserRow<ParserDummy> start_backup_reply[] = {
  1584.     MGM_CMD("start backup reply", NULL, ""),
  1585.     MGM_ARG("result", String, Mandatory, "Error message"),
  1586.     MGM_ARG("id", Int, Optional, "Id of the started backup"),
  1587.     MGM_END()
  1588.   };
  1589.   CHECK_HANDLE(handle, -1);
  1590.   CHECK_CONNECTED(handle, -1);
  1592.   Properties args;
  1593.   args.put("completed", wait_completed);
  1594.   const Properties *reply;
  1595.   { // start backup can take some time, set timeout high
  1596.     Uint64 old_timeout= handle->read_timeout;
  1597.     if (wait_completed == 2)
  1598.       handle->read_timeout= 48*60*60*1000; // 48 hours
  1599.     else if (wait_completed == 1)
  1600.       handle->read_timeout= 10*60*1000; // 10 minutes
  1601.     reply = ndb_mgm_call(handle, start_backup_reply, "start backup", &args);
  1602.     handle->read_timeout= old_timeout;
  1603.   }
  1604.   CHECK_REPLY(reply, -1);
  1606.   BaseString result;
  1607.   reply->get("result", result);
  1608.   reply->get("id", _backup_id);
  1609.   if(strcmp(result.c_str(), "Ok") != 0) {
  1610.     SET_ERROR(handle, NDB_MGM_COULD_NOT_START_BACKUP, result.c_str());
  1611.     delete reply;
  1612.     return -1;
  1613.   }
  1615.   delete reply;
  1616.   return 0;
  1617. }
  1619. extern "C"
  1620. int
  1621. ndb_mgm_abort_backup(NdbMgmHandle handle, unsigned int backupId,
  1622.      struct ndb_mgm_reply* /*reply*/) 
  1623. {
  1624.   SET_ERROR(handle, NDB_MGM_NO_ERROR, "Executing: ndb_mgm_abort_backup");
  1625.   const ParserRow<ParserDummy> stop_backup_reply[] = {
  1626.     MGM_CMD("abort backup reply", NULL, ""),
  1627.     MGM_ARG("result", String, Mandatory, "Error message"),    
  1628.     MGM_END()
  1629.   };
  1630.   CHECK_HANDLE(handle, -1);
  1631.   CHECK_CONNECTED(handle, -1);
  1632.   
  1633.   Properties args;
  1634.   args.put("id", backupId);
  1636.   const Properties *prop;
  1637.   prop = ndb_mgm_call(handle, stop_backup_reply, "abort backup", &args);
  1638.   CHECK_REPLY(prop, -1);
  1640.   const char * buf;
  1641.   prop->get("result", &buf);
  1642.   if(strcmp(buf,"Ok")!=0) {
  1643.     SET_ERROR(handle, NDB_MGM_COULD_NOT_ABORT_BACKUP, buf);
  1644.     delete prop;    
  1645.     return -1;
  1646.   }
  1648.   delete prop;
  1649.   return 0;
  1650. }
  1652. extern "C"
  1653. struct ndb_mgm_configuration *
  1654. ndb_mgm_get_configuration(NdbMgmHandle handle, unsigned int version) {
  1656.   CHECK_HANDLE(handle, 0);
  1657.   CHECK_CONNECTED(handle, 0);
  1659.   Properties args;
  1660.   args.put("version", version);
  1662.   const ParserRow<ParserDummy> reply[] = {
  1663.     MGM_CMD("get config reply", NULL, ""),
  1664.     MGM_ARG("result", String, Mandatory, "Error message"),    
  1665.     MGM_ARG("Content-Length", Int, Optional, "Content length in bytes"),
  1666.     MGM_ARG("Content-Type", String, Optional, "Type (octet-stream)"),
  1667.     MGM_ARG("Content-Transfer-Encoding", String, Optional, "Encoding(base64)"),
  1668.     MGM_END()
  1669.   };
  1670.   
  1671.   const Properties *prop;
  1672.   prop = ndb_mgm_call(handle, reply, "get config", &args);
  1673.   CHECK_REPLY(prop, 0);
  1674.   
  1675.   do {
  1676.     const char * buf;
  1677.     if(!prop->get("result", &buf) || strcmp(buf, "Ok") != 0){
  1678.       fprintf(handle->errstream, "ERROR Message: %snn", buf);
  1679.       break;
  1680.     }
  1682.     buf = "<Unspecified>";
  1683.     if(!prop->get("Content-Type", &buf) || 
  1684.        strcmp(buf, "ndbconfig/octet-stream") != 0){
  1685.       fprintf(handle->errstream, "Unhandled response type: %sn", buf);
  1686.       break;
  1687.     }
  1689.     buf = "<Unspecified>";
  1690.     if(!prop->get("Content-Transfer-Encoding", &buf) 
  1691.        || strcmp(buf, "base64") != 0){
  1692.       fprintf(handle->errstream, "Unhandled encoding: %sn", buf);
  1693.       break;
  1694.     }
  1696.     buf = "<Content-Length Unspecified>";
  1697.     Uint32 len = 0;
  1698.     if(!prop->get("Content-Length", &len)){
  1699.       fprintf(handle->errstream, "Invalid response: %snn", buf);
  1700.       break;
  1701.     }
  1703.     len += 1; // Trailing n
  1704.         
  1705.     char* buf64 = new char[len];
  1706.     int read = 0;
  1707.     size_t start = 0;
  1708.     do {
  1709.       if((read = read_socket(handle->socket, handle->read_timeout, 
  1710.      &buf64[start], len-start)) == -1){
  1711. delete[] buf64; 
  1712. buf64 = 0;
  1713. break;
  1714.       }
  1715.       start += read;
  1716.     } while(start < len);
  1717.     if(buf64 == 0)
  1718.       break;
  1719.     
  1720.     UtilBuffer tmp;
  1721.     const int res = base64_decode(buf64, len-1, tmp);
  1722.     delete[] buf64; 
  1723.     if(res != 0){
  1724.       fprintf(handle->errstream, "Failed to decode buffern");
  1725.       break;
  1726.     }
  1728.     ConfigValuesFactory cvf;
  1729.     const int res2 = cvf.unpack(tmp);
  1730.     if(!res2){
  1731.       fprintf(handle->errstream, "Failed to unpack buffern");
  1732.       break;
  1733.     }
  1735.     delete prop;
  1736.     return (ndb_mgm_configuration*)cvf.m_cfg;
  1737.   } while(0);
  1739.   delete prop;
  1740.   return 0;
  1741. }
  1743. extern "C"
  1744. void
  1745. ndb_mgm_destroy_configuration(struct ndb_mgm_configuration *cfg)
  1746. {
  1747.   if (cfg) {
  1748.     ((ConfigValues *)cfg)->~ConfigValues();
  1749.     free((void *)cfg);
  1750.   }
  1751. }
  1753. extern "C"
  1754. int
  1755. ndb_mgm_set_configuration_nodeid(NdbMgmHandle handle, int nodeid)
  1756. {
  1757.   CHECK_HANDLE(handle, -1);
  1758.   handle->cfg._ownNodeId= nodeid;
  1759.   return 0;
  1760. }
  1762. extern "C"
  1763. int
  1764. ndb_mgm_get_configuration_nodeid(NdbMgmHandle handle)
  1765. {
  1766.   CHECK_HANDLE(handle, 0);
  1767.   return handle->cfg._ownNodeId;
  1768. }
  1770. extern "C"
  1771. int ndb_mgm_get_connected_port(NdbMgmHandle handle)
  1772. {
  1773.   return handle->cfg.ids[handle->cfg_i].port;
  1774. }
  1776. extern "C"
  1777. const char *ndb_mgm_get_connected_host(NdbMgmHandle handle)
  1778. {
  1779.   return handle->cfg.ids[handle->cfg_i].name.c_str();
  1780. }
  1782. extern "C"
  1783. const char *ndb_mgm_get_connectstring(NdbMgmHandle handle, char *buf, int buf_sz)
  1784. {
  1785.   return handle->cfg.makeConnectString(buf,buf_sz);
  1786. }
  1788. extern "C"
  1789. int
  1790. ndb_mgm_alloc_nodeid(NdbMgmHandle handle, unsigned int version, int nodetype)
  1791. {
  1792.   CHECK_HANDLE(handle, 0);
  1793.   CHECK_CONNECTED(handle, 0);
  1794.   union { long l; char c[sizeof(long)]; } endian_check;
  1796.   endian_check.l = 1;
  1798.   int nodeid= handle->cfg._ownNodeId;
  1800.   Properties args;
  1801.   args.put("version", version);
  1802.   args.put("nodetype", nodetype);
  1803.   args.put("nodeid", nodeid);
  1804.   args.put("user", "mysqld");
  1805.   args.put("password", "mysqld");
  1806.   args.put("public key", "a public key");
  1807.   args.put("endian", (endian_check.c[sizeof(long)-1])?"big":"little");
  1809.   const ParserRow<ParserDummy> reply[]= {
  1810.     MGM_CMD("get nodeid reply", NULL, ""),
  1811.       MGM_ARG("nodeid", Int, Optional, "Error message"),
  1812.       MGM_ARG("result", String, Mandatory, "Error message"),
  1813.     MGM_END()
  1814.   };
  1815.   
  1816.   const Properties *prop;
  1817.   prop= ndb_mgm_call(handle, reply, "get nodeid", &args);
  1818.   CHECK_REPLY(prop, -1);
  1820.   nodeid= -1;
  1821.   do {
  1822.     const char * buf;
  1823.     if(!prop->get("result", &buf) || strcmp(buf, "Ok") != 0){
  1824.       const char *hostname= ndb_mgm_get_connected_host(handle);
  1825.       unsigned port=  ndb_mgm_get_connected_port(handle);
  1826.       BaseString err;
  1827.       err.assfmt("Could not alloc node id at %s port %d: %s",
  1828.  hostname, port, buf);
  1829.       setError(handle, NDB_MGM_COULD_NOT_CONNECT_TO_SOCKET, __LINE__,
  1830.        err.c_str());
  1831.       break;
  1832.     }
  1833.     Uint32 _nodeid;
  1834.     if(!prop->get("nodeid", &_nodeid) != 0){
  1835.       fprintf(handle->errstream, "ERROR Message: <nodeid Unspecified>n");
  1836.       break;
  1837.     }
  1838.     nodeid= _nodeid;
  1839.   }while(0);
  1841.   delete prop;
  1842.   return nodeid;
  1843. }
  1845. /*****************************************************************************
  1846.  * Global Replication
  1847.  ******************************************************************************/
  1848. extern "C"
  1849. int 
  1850. ndb_mgm_rep_command(NdbMgmHandle handle, unsigned int request,
  1851.     unsigned int* replication_id,
  1852.     struct ndb_mgm_reply* /*reply*/) 
  1853. {
  1854.   SET_ERROR(handle, NDB_MGM_NO_ERROR, "Executing: ndb_mgm_rep_command");
  1855.   const ParserRow<ParserDummy> replication_reply[] = {
  1856.     MGM_CMD("global replication reply", NULL, ""),
  1857.     MGM_ARG("result", String, Mandatory, "Error message"),
  1858.     MGM_ARG("id", Int, Optional, "Id of global replication"),
  1859.     MGM_END()
  1860.   };
  1861.   CHECK_HANDLE(handle, -1);
  1862.   CHECK_CONNECTED(handle, -1);
  1864.   Properties args;
  1865.   args.put("request", request);
  1866.   const Properties *reply;
  1867.   reply = ndb_mgm_call(handle, replication_reply, "rep", &args);
  1868.   CHECK_REPLY(reply, -1);
  1869.   
  1870.   const char * result;
  1871.   reply->get("result", &result);
  1872.   reply->get("id", replication_id);
  1873.   if(strcmp(result,"Ok")!=0) {
  1874.     delete reply;
  1875.     return -1;
  1876.   }
  1878.   delete reply;
  1879.   return 0;
  1880. }
  1882. extern "C"
  1883. int
  1884. ndb_mgm_set_int_parameter(NdbMgmHandle handle,
  1885.   int node, 
  1886.   int param,
  1887.   unsigned value,
  1888.   struct ndb_mgm_reply*){
  1889.   CHECK_HANDLE(handle, 0);
  1890.   CHECK_CONNECTED(handle, 0);
  1891.   
  1892.   Properties args;
  1893.   args.put("node: ", node);
  1894.   args.put("param: ", param);
  1895.   args.put("value: ", value);
  1896.   
  1897.   const ParserRow<ParserDummy> reply[]= {
  1898.     MGM_CMD("set parameter reply", NULL, ""),
  1899.     MGM_ARG("result", String, Mandatory, "Error message"),
  1900.     MGM_END()
  1901.   };
  1902.   
  1903.   const Properties *prop;
  1904.   prop= ndb_mgm_call(handle, reply, "set parameter", &args);
  1905.   CHECK_REPLY(prop, -1);
  1907.   int res= -1;
  1908.   do {
  1909.     const char * buf;
  1910.     if(!prop->get("result", &buf) || strcmp(buf, "Ok") != 0){
  1911.       fprintf(handle->errstream, "ERROR Message: %sn", buf);
  1912.       break;
  1913.     }
  1914.     res= 0;
  1915.   } while(0);
  1916.   
  1917.   delete prop;
  1918.   return res;
  1919. }
  1921. extern "C"
  1922. int 
  1923. ndb_mgm_set_int64_parameter(NdbMgmHandle handle,
  1924.     int node, 
  1925.     int param,
  1926.     unsigned long long value,
  1927.     struct ndb_mgm_reply*){
  1928.   CHECK_HANDLE(handle, 0);
  1929.   CHECK_CONNECTED(handle, 0);
  1930.   
  1931.   Properties args;
  1932.   args.put("node: ", node);
  1933.   args.put("param: ", param);
  1934.   args.put("value: ", value);
  1935.   
  1936.   const ParserRow<ParserDummy> reply[]= {
  1937.     MGM_CMD("set parameter reply", NULL, ""),
  1938.     MGM_ARG("result", String, Mandatory, "Error message"),
  1939.     MGM_END()
  1940.   };
  1941.   
  1942.   const Properties *prop;
  1943.   prop= ndb_mgm_call(handle, reply, "set parameter", &args);
  1944.   
  1945.   if(prop == NULL) {
  1946.     SET_ERROR(handle, EIO, "Unable set parameter");
  1947.     return -1;
  1948.   }
  1950.   int res= -1;
  1951.   do {
  1952.     const char * buf;
  1953.     if(!prop->get("result", &buf) || strcmp(buf, "Ok") != 0){
  1954.       fprintf(handle->errstream, "ERROR Message: %sn", buf);
  1955.       break;
  1956.     }
  1957.     res= 0;
  1958.   } while(0);
  1959.   
  1960.   delete prop;
  1961.   return res;
  1962. }
  1964. extern "C"
  1965. int
  1966. ndb_mgm_set_string_parameter(NdbMgmHandle handle,
  1967.      int node, 
  1968.      int param,
  1969.      const char * value,
  1970.      struct ndb_mgm_reply*){
  1971.   CHECK_HANDLE(handle, 0);
  1972.   CHECK_CONNECTED(handle, 0);
  1973.   
  1974.   Properties args;
  1975.   args.put("node: ", node);
  1976.   args.put("parameter: ", param);
  1977.   args.put("value: ", value);
  1978.   
  1979.   const ParserRow<ParserDummy> reply[]= {
  1980.     MGM_CMD("set parameter reply", NULL, ""),
  1981.     MGM_ARG("result", String, Mandatory, "Error message"),
  1982.     MGM_END()
  1983.   };
  1984.   
  1985.   const Properties *prop;
  1986.   prop= ndb_mgm_call(handle, reply, "set parameter", &args);
  1987.   
  1988.   if(prop == NULL) {
  1989.     SET_ERROR(handle, EIO, "Unable set parameter");
  1990.     return -1;
  1991.   }
  1993.   int res= -1;
  1994.   do {
  1995.     const char * buf;
  1996.     if(!prop->get("result", &buf) || strcmp(buf, "Ok") != 0){
  1997.       fprintf(handle->errstream, "ERROR Message: %sn", buf);
  1998.       break;
  1999.     }
  2000.     res= 0;
  2001.   } while(0);
  2002.   
  2003.   delete prop;
  2004.   return res;
  2005. }
  2007. extern "C"
  2008. int
  2009. ndb_mgm_purge_stale_sessions(NdbMgmHandle handle, char **purged){
  2010.   CHECK_HANDLE(handle, 0);
  2011.   CHECK_CONNECTED(handle, 0);
  2012.   
  2013.   Properties args;
  2014.   
  2015.   const ParserRow<ParserDummy> reply[]= {
  2016.     MGM_CMD("purge stale sessions reply", NULL, ""),
  2017.     MGM_ARG("purged", String, Optional, ""),
  2018.     MGM_ARG("result", String, Mandatory, "Error message"),
  2019.     MGM_END()
  2020.   };
  2021.   
  2022.   const Properties *prop;
  2023.   prop= ndb_mgm_call(handle, reply, "purge stale sessions", &args);
  2024.   
  2025.   if(prop == NULL) {
  2026.     SET_ERROR(handle, EIO, "Unable to purge stale sessions");
  2027.     return -1;
  2028.   }
  2030.   int res= -1;
  2031.   do {
  2032.     const char * buf;
  2033.     if(!prop->get("result", &buf) || strcmp(buf, "Ok") != 0){
  2034.       fprintf(handle->errstream, "ERROR Message: %sn", buf);
  2035.       break;
  2036.     }
  2037.     if (purged) {
  2038.       if (prop->get("purged", &buf))
  2039. *purged= strdup(buf);
  2040.       else
  2041. *purged= 0;
  2042.     }
  2043.     res= 0;
  2044.   } while(0);
  2045.   delete prop;
  2046.   return res;
  2047. }
  2049. extern "C"
  2050. int
  2051. ndb_mgm_check_connection(NdbMgmHandle handle){
  2052.   CHECK_HANDLE(handle, 0);
  2053.   CHECK_CONNECTED(handle, 0);
  2054.   SocketOutputStream out(handle->socket);
  2055.   SocketInputStream in(handle->socket, handle->read_timeout);
  2056.   char buf[32];
  2058.   if (out.println("check connection"))
  2059.     goto ndb_mgm_check_connection_error;
  2061.   if (out.println(""))
  2062.     goto ndb_mgm_check_connection_error;
  2064.   in.gets(buf, sizeof(buf));
  2065.   if(strcmp("check connection replyn", buf))
  2066.     goto ndb_mgm_check_connection_error;
  2068.   in.gets(buf, sizeof(buf));
  2069.   if(strcmp("result: Okn", buf))
  2070.     goto ndb_mgm_check_connection_error;
  2072.   in.gets(buf, sizeof(buf));
  2073.   if(strcmp("n", buf))
  2074.     goto ndb_mgm_check_connection_error;
  2076.   return 0;
  2078. ndb_mgm_check_connection_error:
  2079.   ndb_mgm_disconnect(handle);
  2080.   return -1;
  2081. }
  2083. template class Vector<const ParserRow<ParserDummy>*>;