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

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

MySQL数据库

开发平台：

Visual C++

Services.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 <ctype.h>
  20. #include <uucode.h>
  21. #include <socket_io.h>
  22. #include <ndb_version.h>
  23. #include <mgmapi.h>
  24. #include <EventLogger.hpp>
  25. #include <signaldata/SetLogLevelOrd.hpp>
  26. #include <LogLevel.hpp>
  27. #include <BaseString.hpp>
  28. #include <Base64.hpp>
  30. #include <ConfigValues.hpp>
  31. #include <mgmapi_configuration.hpp>
  32. #include <Vector.hpp>
  33. #include "Services.hpp"
  35. extern bool g_StopServer;
  37. static const unsigned int MAX_READ_TIMEOUT = 1000 ;
  38. static const unsigned int MAX_WRITE_TIMEOUT = 100 ;
  40. /**
  41.    const char * name;
  42.    const char * realName;
  43.    const Type type;
  44.    const ArgType argType;
  45.    const ArgRequired argRequired;
  46.    const ArgMinMax argMinMax;
  47.    const int minVal;
  48.    const int maxVal;
  49.    void (T::* function)(const class Properties & args);
  50.    const char * description;
  51. */
  53. #define MGM_CMD(name, fun, desc) 
  54.  { name, 
  55.    0, 
  56.    ParserRow<MgmApiSession>::Cmd, 
  57.    ParserRow<MgmApiSession>::String, 
  58.    ParserRow<MgmApiSession>::Optional, 
  59.    ParserRow<MgmApiSession>::IgnoreMinMax, 
  60.    0, 0, 
  61.    fun, 
  62.    desc, 0 }
  64. #define MGM_ARG(name, type, opt, desc) 
  65.  { name, 
  66.    0, 
  67.    ParserRow<MgmApiSession>::Arg, 
  68.    ParserRow<MgmApiSession>::type, 
  69.    ParserRow<MgmApiSession>::opt, 
  70.    ParserRow<MgmApiSession>::IgnoreMinMax, 
  71.    0, 0, 
  72.    0, 
  73.   desc, 0 }
  75. #define MGM_ARG2(name, type, opt, min, max, desc) 
  76.  { name, 
  77.    0, 
  78.    ParserRow<MgmApiSession>::Arg, 
  79.    ParserRow<MgmApiSession>::type, 
  80.    ParserRow<MgmApiSession>::opt, 
  81.    ParserRow<MgmApiSession>::IgnoreMinMax, 
  82.    min, max, 
  83.    0, 
  84.   desc, 0 }
  86. #define MGM_END() 
  87.  { 0, 
  88.    0, 
  89.    ParserRow<MgmApiSession>::Arg, 
  90.    ParserRow<MgmApiSession>::Int, 
  91.    ParserRow<MgmApiSession>::Optional, 
  92.    ParserRow<MgmApiSession>::IgnoreMinMax, 
  93.    0, 0, 
  94.    0, 
  95.    0, 0 }
  97. #define MGM_CMD_ALIAS(name, realName, fun) 
  98.  { name, 
  99.    realName, 
  100.    ParserRow<MgmApiSession>::CmdAlias, 
  101.    ParserRow<MgmApiSession>::Int, 
  102.    ParserRow<MgmApiSession>::Optional, 
  103.    ParserRow<MgmApiSession>::IgnoreMinMax, 
  104.    0, 0, 
  105.    0, 
  106.    0, 0 }
  108. #define MGM_ARG_ALIAS(name, realName, fun) 
  109.  { name, 
  110.    realName, 
  111.    ParserRow<MgmApiSession>::ArgAlias, 
  112.    ParserRow<MgmApiSession>::Int, 
  113.    ParserRow<MgmApiSession>::Optional, 
  114.    ParserRow<MgmApiSession>::IgnoreMinMax, 
  115.    0, 0, 
  116.    0, 
  117.    0, 0 }
  119. const
  120. ParserRow<MgmApiSession> commands[] = {
  121.   MGM_CMD("get statport", &MgmApiSession::getStatPort, ""),
  122.   
  123.   MGM_CMD("get config", &MgmApiSession::getConfig, ""),
  124.     MGM_ARG("version", Int, Mandatory, "Configuration version number"),
  125.     MGM_ARG("node", Int, Optional, "Node ID"),
  127.   MGM_CMD("get nodeid", &MgmApiSession::get_nodeid, ""),
  128.     MGM_ARG("version", Int, Mandatory, "Configuration version number"),
  129.     MGM_ARG("nodetype", Int, Mandatory, "Node type"),
  130.     MGM_ARG("transporter", String, Optional, "Transporter type"),
  131.     MGM_ARG("nodeid", Int, Optional, "Node ID"),
  132.     MGM_ARG("user", String, Mandatory, "Password"),
  133.     MGM_ARG("password", String, Mandatory, "Password"),
  134.     MGM_ARG("public key", String, Mandatory, "Public key"),
  135.     MGM_ARG("endian", String, Optional, "Endianness"),
  137.   MGM_CMD("get version", &MgmApiSession::getVersion, ""),
  138.   
  139.   MGM_CMD("get status", &MgmApiSession::getStatus, ""),
  141.   MGM_CMD("get info clusterlog", &MgmApiSession::getInfoClusterLog, ""),
  143.   MGM_CMD("restart node", &MgmApiSession::restart, ""),
  144.     MGM_ARG("node", String, Mandatory, "Nodes to restart"),
  145.     MGM_ARG("initialstart", Int, Optional, "Initial start"),
  146.     MGM_ARG("nostart", Int, Optional, "No start"),
  147.     MGM_ARG("abort", Int, Optional, "Abort"),
  149.   MGM_CMD("restart all", &MgmApiSession::restartAll, ""),
  150.     MGM_ARG("initialstart", Int, Optional, "Initial start"),
  151.     MGM_ARG("nostart", Int, Optional, "No start"),
  152.     MGM_ARG("abort", Int, Optional, "Abort"),
  154.   MGM_CMD("insert error", &MgmApiSession::insertError, ""),
  155.     MGM_ARG("node", Int, Mandatory, "Node to receive error"),
  156.     MGM_ARG("error", Int, Mandatory, "Errorcode to insert"),
  158.   MGM_CMD("set trace", &MgmApiSession::setTrace, ""),
  159.     MGM_ARG("node", Int, Mandatory, "Node"),
  160.     MGM_ARG("trace", Int, Mandatory, "Trace number"),
  162.   MGM_CMD("log signals", &MgmApiSession::logSignals, ""),
  163.     MGM_ARG("node", Int, Mandatory, "Node"),
  164.     MGM_ARG("blocks", String, Mandatory, "Blocks (space separated)"),
  165.     MGM_ARG("in", Int, Mandatory, "Log input signals"),
  166.     MGM_ARG("out", Int, Mandatory, "Log output signals"),
  168.   MGM_CMD("start signallog", &MgmApiSession::startSignalLog, ""),
  169.     MGM_ARG("node", Int, Mandatory, "Node"),
  171.   MGM_CMD("stop signallog", &MgmApiSession::stopSignalLog, ""),
  172.     MGM_ARG("node", Int, Mandatory, "Node"),
  174.   MGM_CMD("dump state", &MgmApiSession::dumpState, ""),
  175.     MGM_ARG("node", Int, Mandatory ,"Node"),
  176.     MGM_ARG("args", String, Mandatory, "Args(space separated int's)"),
  178.   MGM_CMD("start backup", &MgmApiSession::startBackup, ""),
  179.     MGM_ARG("completed", Int, Optional ,"Wait until completed"),
  181.   MGM_CMD("abort backup", &MgmApiSession::abortBackup, ""),
  182.     MGM_ARG("id", Int, Mandatory, "Backup id"),
  184.   /**
  185.    *  Global Replication
  186.    */
  187.   MGM_CMD("rep", &MgmApiSession::repCommand, ""),
  188.     MGM_ARG("request", Int, Mandatory, "Command"),
  190.   MGM_CMD("stop", &MgmApiSession::stop, ""),
  191.     MGM_ARG("node", String, Mandatory, "Node"),
  192.     MGM_ARG("abort", Int, Mandatory, "Node"),
  194.   MGM_CMD("stop all", &MgmApiSession::stopAll, ""),
  195.     MGM_ARG("abort", Int, Mandatory, "Node"),
  196.   
  197.   MGM_CMD("enter single user", &MgmApiSession::enterSingleUser, ""),
  198.     MGM_ARG("nodeId", Int, Mandatory, "Node"),
  199.   
  200.   MGM_CMD("exit single user", &MgmApiSession::exitSingleUser, ""),
  201.   
  203.   MGM_CMD("start", &MgmApiSession::start, ""),
  204.     MGM_ARG("node", Int, Mandatory, "Node"),
  206.   MGM_CMD("start all", &MgmApiSession::startAll, ""),
  208.   MGM_CMD("bye", &MgmApiSession::bye, ""),
  210.   MGM_CMD("set loglevel", &MgmApiSession::setLogLevel, ""),
  211.     MGM_ARG("node", Int, Mandatory, "Node"),
  212.     MGM_ARG("category", Int, Mandatory, "Event category"),
  213.     MGM_ARG("level", Int, Mandatory, "Log level (0-15)"),
  215.   MGM_CMD("set cluster loglevel", &MgmApiSession::setClusterLogLevel, ""),
  216.     MGM_ARG("node", Int, Mandatory, "Node"),
  217.     MGM_ARG("category", Int, Mandatory, "Event category"),
  218.     MGM_ARG("level", Int, Mandatory, "Log level (0-15)"),
  220.   MGM_CMD("set logfilter", &MgmApiSession::setLogFilter, ""),
  221.     MGM_ARG("level", Int, Mandatory, "Severety level"),
  222.     MGM_ARG("enable", Int, Mandatory, "1=disable, 0=enable, -1=toggle"),
  224.   MGM_CMD("set parameter", &MgmApiSession::setParameter, ""),
  225.     MGM_ARG("node", String, Mandatory, "Node"),
  226.     MGM_ARG("parameter", String, Mandatory, "Parameter"),
  227.     MGM_ARG("value", String, Mandatory, "Value"),
  229.   MGM_CMD("listen event", &MgmApiSession::listen_event, ""),
  230.     MGM_ARG("node", Int, Optional, "Node"),  
  231.     MGM_ARG("filter", String, Mandatory, "Event category"),
  233.   MGM_CMD("purge stale sessions", &MgmApiSession::purge_stale_sessions, ""),
  235.   MGM_CMD("check connection", &MgmApiSession::check_connection, ""),
  237.   MGM_END()
  238. };
  240. MgmApiSession::MgmApiSession(class MgmtSrvr & mgm, NDB_SOCKET_TYPE sock)
  241.   : SocketServer::Session(sock), m_mgmsrv(mgm)
  242. {
  243.   DBUG_ENTER("MgmApiSession::MgmApiSession");
  244.   m_input = new SocketInputStream(sock);
  245.   m_output = new SocketOutputStream(sock);
  246.   m_parser = new Parser_t(commands, *m_input, true, true, true);
  247.   m_allocated_resources= new MgmtSrvr::Allocated_resources(m_mgmsrv);
  248.   DBUG_VOID_RETURN;
  249. }
  251. MgmApiSession::~MgmApiSession()
  252. {
  253.   DBUG_ENTER("MgmApiSession::~MgmApiSession");
  254.   if (m_input)
  255.     delete m_input;
  256.   if (m_output)
  257.     delete m_output;
  258.   if (m_parser)
  259.     delete m_parser;
  260.   if (m_allocated_resources)
  261.     delete m_allocated_resources;
  262.   if(m_socket != NDB_INVALID_SOCKET)
  263.   {
  264.     NDB_CLOSE_SOCKET(m_socket);
  265.     m_socket= NDB_INVALID_SOCKET;
  266.   }
  267.   DBUG_VOID_RETURN;
  268. }
  270. void
  271. MgmApiSession::runSession()
  272. {
  273.   DBUG_ENTER("MgmApiSession::runSession");
  275.   Parser_t::Context ctx;
  276.   while(!m_stop) {
  277.     m_parser->run(ctx, *this);
  279.     if(ctx.m_currentToken == 0)
  280.       break;
  282.     switch(ctx.m_status) {
  283.     case Parser_t::UnknownCommand:
  284. #ifdef MGM_GET_CONFIG_BACKWARDS_COMPAT
  285.       /* Backwards compatibility for old NDBs that still use
  286.        * the old "GET CONFIG" command.
  287.        */
  288.   size_t i;
  289.       for(i=0; i<strlen(ctx.m_currentToken); i++)
  290. ctx.m_currentToken[i] = toupper(ctx.m_currentToken[i]);
  292.       if(strncmp("GET CONFIG ", 
  293.  ctx.m_currentToken,
  294.  strlen("GET CONFIG ")) == 0)
  295. getConfig_old(ctx);
  296. #endif /* MGM_GET_CONFIG_BACKWARDS_COMPAT */
  297.       break;
  298.     default:
  299.       break;
  300.     }
  301.   }
  302.   if(m_socket != NDB_INVALID_SOCKET)
  303.   {
  304.     NDB_CLOSE_SOCKET(m_socket);
  305.     m_socket= NDB_INVALID_SOCKET;
  306.   }
  308.   DBUG_VOID_RETURN;
  309. }
  311. #ifdef MGM_GET_CONFIG_BACKWARDS_COMPAT
  312. void
  313. MgmApiSession::getConfig_old(Parser_t::Context &ctx) {
  314.   Properties args;
  316.   Uint32 version, node;
  318.   if(sscanf(ctx.m_currentToken, "GET CONFIG %d %d",
  319.     (int *)&version, (int *)&node) != 2) {
  320.     m_output->println("Expected 2 arguments for GET CONFIG");
  321.     return;
  322.   }
  324.   /* Put arguments in properties object so we can call the real function */  
  325.   args.put("version", version);
  326.   args.put("node", node);
  327.   getConfig_common(ctx, args, true);
  328. }
  329. #endif /* MGM_GET_CONFIG_BACKWARDS_COMPAT */
  331. void
  332. MgmApiSession::getConfig(Parser_t::Context &ctx, 
  333.  const class Properties &args) {
  334.   getConfig_common(ctx, args);
  335. }
  337. static Properties *
  338. backward(const char * base, const Properties* reply){
  339.   Properties * ret = new Properties();
  340.   Properties::Iterator it(reply);
  341.   for(const char * name = it.first(); name != 0; name=it.next()){
  342.     PropertiesType type;
  343.     reply->getTypeOf(name, &type);
  344.     switch(type){
  345.     case PropertiesType_Uint32:{
  346.       Uint32 val;
  347.       reply->get(name, &val);
  348.       ret->put(name, val);
  349.     }
  350.       break;
  351.     case PropertiesType_char:
  352.       {
  353. const char * val;
  354. reply->get(name, &val);
  355. ret->put(name, val);
  356. if(!strcmp(name, "Type") && !strcmp(val, "DB")){
  357.   ret->put("NoOfDiskBufferPages", (unsigned)0);
  358.   ret->put("NoOfDiskFiles", (unsigned)0);
  359.   ret->put("NoOfDiskClusters", (unsigned)0);
  360.   ret->put("NoOfFreeDiskClusters", (unsigned)0);
  361.   ret->put("NoOfDiskClustersPerDiskFile", (unsigned)0);
  362.   ret->put("NoOfConcurrentCheckpointsDuringRestart", (unsigned)1);
  363.   ret->put("NoOfConcurrentCheckpointsAfterRestart", (unsigned)1);
  364.   ret->put("NoOfConcurrentProcessesHandleTakeover", (unsigned)1);
  365. }
  366.       }
  367.       break;
  368.     case PropertiesType_Properties:
  369.       {
  370. const Properties * recurse;
  371. reply->get(name, &recurse);
  372. Properties * val = backward(name, recurse);
  373. ret->put(name, val);
  374.       }
  375.       break;
  376.     case PropertiesType_Uint64:
  377.       break;
  378.     }
  379.   }
  380.   return ret;
  381. }
  383. void
  384. MgmApiSession::get_nodeid(Parser_t::Context &,
  385.   const class Properties &args)
  386. {
  387.   const char *cmd= "get nodeid reply";
  388.   Uint32 version, nodeid= 0, nodetype= 0xff;
  389.   const char * transporter;
  390.   const char * user;
  391.   const char * password;
  392.   const char * public_key;
  393.   const char * endian= NULL;
  394.   union { long l; char c[sizeof(long)]; } endian_check;
  396.   args.get("version", &version);
  397.   args.get("nodetype", &nodetype);
  398.   args.get("transporter", &transporter);
  399.   args.get("nodeid", &nodeid);
  400.   args.get("user", &user);
  401.   args.get("password", &password);
  402.   args.get("public key", &public_key);
  403.   args.get("endian", &endian);
  405.   endian_check.l = 1;
  406.   if(endian 
  407.      && strcmp(endian,(endian_check.c[sizeof(long)-1])?"big":"little")!=0) {
  408.     m_output->println(cmd);
  409.     m_output->println("result: Node does not have the same endianness as the management server.");
  410.     m_output->println("");
  411.     return;
  412.   }
  414.   bool compatible;
  415.   switch (nodetype) {
  416.   case NODE_TYPE_MGM:
  417.   case NODE_TYPE_API:
  418.     compatible = ndbCompatible_mgmt_api(NDB_VERSION, version);
  419.     break;
  420.   case NODE_TYPE_DB:
  421.     compatible = ndbCompatible_mgmt_ndb(NDB_VERSION, version);
  422.     break;
  423.   default:
  424.     m_output->println(cmd);
  425.     m_output->println("result: unknown nodetype %d", nodetype);
  426.     m_output->println("");
  427.     return;
  428.   }
  430.   struct sockaddr addr;
  431.   SOCKET_SIZE_TYPE addrlen= sizeof(addr);
  432.   int r = getpeername(m_socket, &addr, &addrlen);
  433.   if (r != 0 ) {
  434.     m_output->println(cmd);
  435.     m_output->println("result: getpeername(%d) failed, err= %d", m_socket, r);
  436.     m_output->println("");
  437.     return;
  438.   }
  440.   NodeId tmp= nodeid;
  441.   if(tmp == 0 || !m_allocated_resources->is_reserved(tmp)){
  442.     BaseString error_string;
  443.     if (!m_mgmsrv.alloc_node_id(&tmp, (enum ndb_mgm_node_type)nodetype, 
  444. &addr, &addrlen, error_string)){
  445.       const char *alias;
  446.       const char *str;
  447.       alias= ndb_mgm_get_node_type_alias_string((enum ndb_mgm_node_type)
  448. nodetype, &str);
  449.       m_output->println(cmd);
  450.       m_output->println("result: %s", error_string.c_str());
  451.       m_output->println("");
  452.       return;
  453.     }
  454.   }    
  455.   
  456. #if 0
  457.   if (!compatible){
  458.     m_output->println(cmd);
  459.     m_output->println("result: incompatible version mgmt 0x%x and node 0x%x",
  460.       NDB_VERSION, version);
  461.     m_output->println("");
  462.     return;
  463.   }
  464. #endif
  465.   
  466.   m_output->println(cmd);
  467.   m_output->println("nodeid: %u", tmp);
  468.   m_output->println("result: Ok");
  469.   m_output->println("");
  470.   m_allocated_resources->reserve_node(tmp);
  471.   
  472.   return;
  473. }
  475. void
  476. MgmApiSession::getConfig_common(Parser_t::Context &,
  477. const class Properties &args,
  478. bool compat) {
  479.   Uint32 version, node = 0;
  481.   args.get("version", &version);
  482.   args.get("node", &node);
  484.   const Config *conf = m_mgmsrv.getConfig();
  485.   if(conf == NULL) {
  486.     m_output->println("get config reply");
  487.     m_output->println("result: Could not fetch configuration");
  488.     m_output->println("");
  489.     return;
  490.   }
  492.   if(version > 0 && version < makeVersion(3, 5, 0) && compat){
  493.     Properties *reply = backward("", conf->m_oldConfig);
  494.     reply->put("Version", version);
  495.     reply->put("LocalNodeId", node);
  497.     backward("", reply);
  498.     //reply->print();
  499.     
  500.     const Uint32 size = reply->getPackedSize();
  501.     Uint32 *buffer = new Uint32[size/4+1];
  502.     
  503.     reply->pack(buffer);
  504.     delete reply;
  505.     
  506.     const int uurows = (size + 44)/45;
  507.     char * uubuf = new char[uurows * 62+5];
  508.       
  509.     const int uusz = uuencode_mem(uubuf, (char *)buffer, size);
  510.     delete[] buffer;
  511.       
  512.     m_output->println("GET CONFIG %d %d %d %d %d",
  513.       0, version, node, size, uusz);
  514.     
  515.     m_output->println("begin 664 Ndb_cfg.bin");
  516.       
  517.     /* XXX Need to write directly to the socket, because the uubuf is not
  518.      * NUL-terminated. This could/should probably be done in a nicer way.
  519.      */
  520.     write_socket(m_socket, MAX_WRITE_TIMEOUT, uubuf, uusz);
  521.     delete[] uubuf;
  522.       
  523.     m_output->println("end");
  524.     m_output->println("");
  525.     return;
  526.   }
  528.   if(compat){
  529.     m_output->println("GET CONFIG %d %d %d %d %d",1, version, 0, 0, 0);
  530.     return;
  531.   }
  533.   if(node != 0){
  534.     bool compatible;
  535.     switch (m_mgmsrv.getNodeType(node)) {
  536.     case NDB_MGM_NODE_TYPE_NDB:
  537.       compatible = ndbCompatible_mgmt_ndb(NDB_VERSION, version);
  538.       break;
  539.     case NDB_MGM_NODE_TYPE_API:
  540.     case NDB_MGM_NODE_TYPE_MGM:
  541.       compatible = ndbCompatible_mgmt_api(NDB_VERSION, version);
  542.       break;
  543.     default:
  544.       m_output->println("get config");
  545.       m_output->println("result: unrecognignized node type");
  546.       m_output->println("");
  547.       return;
  548.     }
  549.     
  550.     if (!compatible){
  551.       m_output->println("get config");
  552.       m_output->println("result: incompatible version mgmt 0x%x and node 0x%x",
  553. NDB_VERSION, version);
  554.       m_output->println("");
  555.       return;
  556.     }
  557.   }  
  558.   
  559.   const ConfigValues * cfg = &conf->m_configValues->m_config;
  560.   const Uint32 size = cfg->getPackedSize();
  561.   
  562.   UtilBuffer src;
  563.   cfg->pack(src);
  564.   
  565.   BaseString str;
  566.   int res = base64_encode(src, str);
  567.   
  568.   m_output->println("get config reply");
  569.   m_output->println("result: Ok");
  570.   m_output->println("Content-Length: %d", str.length());
  571.   m_output->println("Content-Type: ndbconfig/octet-stream");
  572.   m_output->println("Content-Transfer-Encoding: base64");
  573.   m_output->println("");
  574.   m_output->println(str.c_str());
  576.   return;
  577. }
  579. void
  580. MgmApiSession::getStatPort(Parser_t::Context &, 
  581.    const class Properties &) {
  583.   m_output->println("get statport reply");
  584.   m_output->println("tcpport: %d", 0);
  585.   m_output->println("");
  586. }
  588. void
  589. MgmApiSession::insertError(Parser<MgmApiSession>::Context &,
  590.    Properties const &args) {
  591.   Uint32 node = 0, error = 0;
  593.   args.get("node", &node);
  594.   args.get("error", &error);
  596.   int result = m_mgmsrv.insertError(node, error);
  598.   m_output->println("insert error reply");
  599.   if(result != 0)
  600.     m_output->println("result: %s", get_error_text(result));
  601.   else
  602.     m_output->println("result: Ok");
  603.   m_output->println("");
  604. }
  606. void
  607. MgmApiSession::setTrace(Parser<MgmApiSession>::Context &,
  608. Properties const &args) {
  609.   Uint32 node = 0, trace = 0;
  611.   args.get("node", &node);
  612.   args.get("trace", &trace);
  614.   int result = m_mgmsrv.setTraceNo(node, trace);
  616.   m_output->println("set trace reply");
  617.   if(result != 0)
  618.     m_output->println("result: %s", get_error_text(result));
  619.   else
  620.     m_output->println("result: Ok");
  621.   m_output->println("");
  622. }
  624. void
  625. MgmApiSession::getVersion(Parser<MgmApiSession>::Context &,
  626.   Properties const &) {
  627.   m_output->println("version");
  628.   m_output->println("id: %d", NDB_VERSION);
  629.   m_output->println("major: %d", getMajor(NDB_VERSION));
  630.   m_output->println("minor: %d", getMinor(NDB_VERSION));
  631.   m_output->println("string: %s", NDB_VERSION_STRING);
  632.   m_output->println("");
  633. }
  635. void
  636. MgmApiSession::startBackup(Parser<MgmApiSession>::Context &,
  637.    Properties const &args) {
  638.   DBUG_ENTER("MgmApiSession::startBackup");
  639.   unsigned backupId;
  640.   Uint32 completed= 2;
  641.   int result;
  643.   args.get("completed", &completed);
  645.   result = m_mgmsrv.startBackup(backupId, completed);
  647.   m_output->println("start backup reply");
  648.   if(result != 0)
  649.   {
  650.     m_output->println("result: %s", get_error_text(result));
  651.   }
  652.   else{
  653.     m_output->println("result: Ok");
  654.     m_output->println("id: %d", backupId);
  655.   }
  656.   m_output->println("");
  657.   DBUG_VOID_RETURN;
  658. }
  660. void
  661. MgmApiSession::abortBackup(Parser<MgmApiSession>::Context &,
  662.    Properties const &args) {
  663.   Uint32 id = 0;
  665.   args.get("id", &id);
  667.   int result = m_mgmsrv.abortBackup(id);
  669.   m_output->println("abort backup reply");
  670.   if(result != 0)
  671.     m_output->println("result: %s", get_error_text(result));
  672.   else
  673.     m_output->println("result: Ok");
  674.   m_output->println("");
  675. }
  677. /*****************************************************************************
  678.  * Global Replication
  679.  *****************************************************************************/
  681. void
  682. MgmApiSession::repCommand(Parser<MgmApiSession>::Context &,
  683.   Properties const &args) {
  684.   
  685.   Uint32 request = 0;
  686.   args.get("request", &request);
  687.   
  688.   Uint32 repReqId;
  689.   int result = m_mgmsrv.repCommand(&repReqId, request, true);
  690.   
  691.   m_output->println("global replication reply");
  692.   if(result != 0)
  693.     m_output->println("result: %s", get_error_text(result));
  694.   else{
  695.     m_output->println("result: Ok");
  696.     m_output->println("id: %d", repReqId);
  697.   }
  698.   m_output->println("");
  699. }
  701. /*****************************************************************************/
  703. void
  704. MgmApiSession::dumpState(Parser<MgmApiSession>::Context &,
  705.  Properties const &args) {
  706.   Uint32 node;
  707.   BaseString args_str;
  709.   args.get("node", &node);
  710.   args.get("args", args_str);
  712.   int result = m_mgmsrv.dumpState(node, args_str.c_str());
  713.   m_output->println("dump state reply");
  714.   if(result != 0)
  715.     m_output->println("result: %s", get_error_text(result));
  716.   else
  717.     m_output->println("result: Ok");
  718.   m_output->println("");
  719. }
  722. void
  723. MgmApiSession::bye(Parser<MgmApiSession>::Context &,
  724.    Properties const &) {
  725.   m_stop = true;
  726. }
  728. void
  729. MgmApiSession::setClusterLogLevel(Parser<MgmApiSession>::Context &,
  730.   Properties const &args) {
  731.   const char *reply= "set cluster loglevel reply";
  732.   Uint32 node, level, cat;
  733.   BaseString errorString;
  734.   SetLogLevelOrd logLevel;
  735.   int result;
  736.   DBUG_ENTER("MgmApiSession::setClusterLogLevel");
  737.   args.get("node", &node);
  738.   args.get("category", &cat);
  739.   args.get("level", &level);
  741.   DBUG_PRINT("enter",("node=%d, category=%d, level=%d", node, cat, level));
  743.   /* XXX should use constants for this value */
  744.   if(level > 15) {
  745.     m_output->println(reply);
  746.     m_output->println("result: Invalid loglevel %d", level);
  747.     m_output->println("");
  748.     DBUG_VOID_RETURN;
  749.   }
  751.   LogLevel::EventCategory category= 
  752.     (LogLevel::EventCategory)(cat-(int)CFG_MIN_LOGLEVEL);
  754.   m_mgmsrv.m_event_listner.lock();
  755.   if (m_mgmsrv.m_event_listner[0].m_logLevel.setLogLevel(category,level))
  756.   {
  757.     m_output->println(reply);
  758.     m_output->println("result: Invalid category %d", category);
  759.     m_output->println("");
  760.     m_mgmsrv.m_event_listner.unlock();
  761.     DBUG_VOID_RETURN;
  762.   }
  763.   m_mgmsrv.m_event_listner.unlock();
  765.   {
  766.     LogLevel ll;
  767.     ll.setLogLevel(category,level);
  768.     m_mgmsrv.m_event_listner.update_max_log_level(ll);
  769.   }
  771.   m_output->println(reply);
  772.   m_output->println("result: Ok");
  773.   m_output->println("");
  774.   DBUG_VOID_RETURN;
  775. }
  777. void
  778. MgmApiSession::setLogLevel(Parser<MgmApiSession>::Context &,
  779.    Properties const &args) {
  780.   Uint32 node = 0, level = 0, cat;
  781.   BaseString errorString;
  782.   SetLogLevelOrd logLevel;
  783.   int result;
  784.   logLevel.clear();
  785.   args.get("node", &node);
  786.   args.get("category", &cat);
  787.   args.get("level", &level);
  789.   /* XXX should use constants for this value */
  790.   if(level > 15) {
  791.     m_output->println("set loglevel reply");
  792.     m_output->println("result: Invalid loglevel", errorString.c_str());
  793.     m_output->println("");
  794.     return;
  795.   }
  797.   LogLevel::EventCategory category= 
  798.     (LogLevel::EventCategory)(cat-(int)CFG_MIN_LOGLEVEL);
  800.   {
  801.     LogLevel ll;
  802.     ll.setLogLevel(category,level);
  803.     m_mgmsrv.m_event_listner.update_max_log_level(ll);
  804.   }
  806.   m_output->println("set loglevel reply");
  807.   m_output->println("result: Ok");
  808.   m_output->println("");
  809. }
  811. void
  812. MgmApiSession::stopSignalLog(Parser<MgmApiSession>::Context &,
  813.      Properties const &args) {
  814.   Uint32 node;
  816.   args.get("node", &node);
  818.   int result = m_mgmsrv.stopSignalTracing(node);
  820.   m_output->println("stop signallog");
  821.   if(result != 0)
  822.     m_output->println("result: %s", get_error_text(result));
  823.   else
  824.     m_output->println("result: Ok");
  825.   m_output->println("");
  826. }
  828. void
  829. MgmApiSession::restart(Parser<MgmApiSession>::Context &,
  830.        Properties const &args) {
  831.   Uint32
  832.     nostart = 0,
  833.     initialstart = 0,
  834.     abort = 0;
  835.   char *nodes_str;
  836.   Vector<NodeId> nodes;
  837.     
  838.   args.get("initialstart", &initialstart);
  839.   args.get("nostart", &nostart);
  840.   args.get("abort", &abort);
  841.   args.get("node", (const char **)&nodes_str);
  843.   char *p, *last;
  844.   for((p = strtok_r(nodes_str, " ", &last));
  845.       p;
  846.       (p = strtok_r(NULL, " ", &last))) {
  847.     nodes.push_back(atoi(p));
  848.   }
  850.   int restarted = 0;
  851.   int result = 0;
  853.   for(size_t i = 0; i < nodes.size(); i++)
  854.     if((result = m_mgmsrv.restartNode(nodes[i],
  855.       nostart != 0,
  856.       initialstart != 0,
  857.       abort != 0)) == 0)
  858.       restarted++;
  859.   
  860.   m_output->println("restart reply");
  861.   if(result != 0){
  862.     m_output->println("result: %d-%s", result, get_error_text(result));
  863.   } else
  864.     m_output->println("result: Ok");
  865.   m_output->println("restarted: %d", restarted);
  866.   m_output->println("");
  867. }
  869. void
  870. MgmApiSession::restartAll(Parser<MgmApiSession>::Context &, 
  871.   Properties const &args)
  872. {
  873.   Uint32 nostart = 0;
  874.   Uint32 initialstart = 0;
  875.   Uint32 abort = 0;
  876.   
  877.   args.get("initialstart", &initialstart);
  878.   args.get("abort", &abort);
  879.   args.get("nostart", &nostart);
  880.   
  881.   int count = 0;
  882.   int result = m_mgmsrv.restart(nostart, initialstart, abort, &count);
  884.   m_output->println("restart reply");
  885.   if(result != 0)
  886.     m_output->println("result: %s", get_error_text(result));
  887.   else
  888.     m_output->println("result: Ok");
  889.   m_output->println("restarted: %d", count);
  890.   m_output->println("");
  891. }
  893. static void
  894. printNodeStatus(OutputStream *output,
  895. MgmtSrvr &mgmsrv,
  896. enum ndb_mgm_node_type type) {
  897.   NodeId nodeId = 0;
  898.   while(mgmsrv.getNextNodeId(&nodeId, type)) {
  899.     enum ndb_mgm_node_status status;
  900.     Uint32 startPhase = 0, 
  901.       version = 0, 
  902.       dynamicId = 0, 
  903.       nodeGroup = 0,
  904.       connectCount = 0;
  905.     bool system;
  906.     const char *address= NULL;
  907.     mgmsrv.status(nodeId, &status, &version, &startPhase,
  908.   &system, &dynamicId, &nodeGroup, &connectCount,
  909.   &address);
  910.     output->println("node.%d.type: %s",
  911.       nodeId,
  912.       ndb_mgm_get_node_type_string(type));
  913.     output->println("node.%d.status: %s",
  914.       nodeId,
  915.       ndb_mgm_get_node_status_string(status));
  916.     output->println("node.%d.version: %d", nodeId, version);
  917.     output->println("node.%d.startphase: %d", nodeId, startPhase);
  918.     output->println("node.%d.dynamic_id: %d", nodeId, dynamicId);
  919.     output->println("node.%d.node_group: %d", nodeId, nodeGroup);
  920.     output->println("node.%d.connect_count: %d", nodeId, connectCount);
  921.     output->println("node.%d.address: %s", nodeId, address ? address : "");
  922.   }
  924. }
  926. void
  927. MgmApiSession::getStatus(Parser<MgmApiSession>::Context &,
  928.  Properties const &) {
  929.   int noOfNodes = 0;
  931.   NodeId nodeId = 0;
  932.   while(m_mgmsrv.getNextNodeId(&nodeId, NDB_MGM_NODE_TYPE_NDB)){
  933.     noOfNodes++;
  934.   }
  935.   nodeId = 0;
  936.   while(m_mgmsrv.getNextNodeId(&nodeId, NDB_MGM_NODE_TYPE_API)){
  937.     noOfNodes++;
  938.   }
  939.   nodeId = 0;
  940.   while(m_mgmsrv.getNextNodeId(&nodeId, NDB_MGM_NODE_TYPE_MGM)){
  941.     noOfNodes++;
  942.   }
  943.   
  944.   m_output->println("node status");
  945.   m_output->println("nodes: %d", noOfNodes);
  946.   printNodeStatus(m_output, m_mgmsrv, NDB_MGM_NODE_TYPE_NDB);
  947.   printNodeStatus(m_output, m_mgmsrv, NDB_MGM_NODE_TYPE_MGM);
  948.   printNodeStatus(m_output, m_mgmsrv, NDB_MGM_NODE_TYPE_API);
  950.   nodeId = 0;
  952.   m_output->println("");
  953. }
  955. void
  956. MgmApiSession::getInfoClusterLog(Parser<MgmApiSession>::Context &,
  957.     Properties const &) {
  958.   const char* names[] = { "enabled",
  959.   "debug",
  960.   "info",
  961.   "warning",
  962.   "error",
  963.   "critical",
  964.   "alert" };
  965.   
  966.   m_output->println("clusterlog");
  967.   for(int i = 0; i < 7; i++) {
  968.     m_output->println("%s: %d",
  969.       names[i], m_mgmsrv.isEventLogFilterEnabled(i));
  970.   }
  971.   m_output->println("");
  972. }
  974. void
  975. MgmApiSession::stop(Parser<MgmApiSession>::Context &,
  976.     Properties const &args) {
  977.   Uint32 abort;
  978.   char *nodes_str;
  979.   Vector<NodeId> nodes;
  981.   args.get("node", (const char **)&nodes_str);
  982.   if(nodes_str == NULL)
  983.     return;
  984.   args.get("abort", &abort);
  986.   char *p, *last;
  987.   for((p = strtok_r(nodes_str, " ", &last));
  988.       p;
  989.       (p = strtok_r(NULL, " ", &last))) {
  990.     nodes.push_back(atoi(p));
  991.   }
  993.   int stop_self= 0;
  994.   size_t i;
  996.   for(i=0; i < nodes.size(); i++) {
  997.     if (nodes[i] == m_mgmsrv.getOwnNodeId()) {
  998.       stop_self= 1;
  999.       if (i != nodes.size()-1) {
  1000. m_output->println("stop reply");
  1001. m_output->println("result: server must be stopped last");
  1002. m_output->println("");
  1003. return;
  1004.       }
  1005.     }
  1006.   }
  1008.   int stopped = 0, result = 0;
  1009.   
  1010.   for(i=0; i < nodes.size(); i++)
  1011.     if (nodes[i] != m_mgmsrv.getOwnNodeId()) {
  1012.       if((result = m_mgmsrv.stopNode(nodes[i], abort != 0)) == 0)
  1013. stopped++;
  1014.     } else
  1015.       stopped++;
  1017.   m_output->println("stop reply");
  1018.   if(result != 0)
  1019.     m_output->println("result: %s", get_error_text(result));
  1020.   else
  1021.     m_output->println("result: Ok");
  1022.   m_output->println("stopped: %d", stopped);
  1023.   m_output->println("");
  1025.   if (stop_self)
  1026.     g_StopServer= true;
  1027. }
  1030. void
  1031. MgmApiSession::stopAll(Parser<MgmApiSession>::Context &,
  1032.       Properties const &args) {
  1033.   int stopped = 0;
  1034.   Uint32 abort;
  1035.   args.get("abort", &abort);
  1037.   int result = m_mgmsrv.stop(&stopped, abort != 0);
  1039.   m_output->println("stop reply");
  1040.   if(result != 0)
  1041.     m_output->println("result: %s", get_error_text(result));
  1042.   else
  1043.     m_output->println("result: Ok");
  1044.   m_output->println("stopped: %d", stopped);
  1045.   m_output->println("");
  1046. }
  1048. void
  1049. MgmApiSession::enterSingleUser(Parser<MgmApiSession>::Context &,
  1050.   Properties const &args) {
  1051.   int stopped = 0;
  1052.   Uint32 nodeId = 0;
  1053.   args.get("nodeId", &nodeId);
  1054.   int result = m_mgmsrv.enterSingleUser(&stopped, nodeId);
  1055.   m_output->println("enter single user reply");
  1056.   if(result != 0) {
  1057.     m_output->println("result: %s", get_error_text(result));
  1058.   }
  1059.   else {
  1060.     m_output->println("result: Ok");
  1061.   }
  1062.   m_output->println("");
  1063. }
  1065. void
  1066. MgmApiSession::exitSingleUser(Parser<MgmApiSession>::Context &,
  1067.       Properties const &args) {
  1068.   int stopped = 0;
  1069.   int result = m_mgmsrv.exitSingleUser(&stopped, false);
  1070.   m_output->println("exit single user reply");
  1071.   if(result != 0)
  1072.     m_output->println("result: %s", get_error_text(result));
  1073.   else
  1074.     m_output->println("result: Ok");
  1075.   m_output->println("");
  1076. }
  1079. void
  1080. MgmApiSession::startSignalLog(Parser<MgmApiSession>::Context &,
  1081.       Properties const &args) {
  1082.   Uint32 node;
  1084.   args.get("node", &node);
  1086.   int result = m_mgmsrv.startSignalTracing(node);
  1088.   m_output->println("start signallog reply");
  1089.   if(result != 0)
  1090.     m_output->println("result: %s", get_error_text(result));
  1091.   else
  1092.     m_output->println("result: Ok");
  1093.   m_output->println("");
  1094. }
  1096. void
  1097. MgmApiSession::logSignals(Parser<MgmApiSession>::Context &,
  1098.    Properties const &args) {
  1099.   Uint32 node = 0, in = 0, out = 0;
  1100.   //  BaseString blocks;
  1101.   BaseString blockList;
  1102.   char * blockName;
  1103.   args.get("node", &node);
  1104.   args.get("in", &in);
  1105.   args.get("out", &out);
  1106.   args.get("blocks", blockList);
  1107.   // fast fix - pekka
  1108.   char buf[200];
  1109.   BaseString::snprintf(buf, 200, "%s", blockList.c_str());
  1110.   Vector<BaseString> blocks;  
  1112.   blockName=strtok(buf,"|");
  1113.   while( blockName != NULL)
  1114.     {
  1115.       blocks.push_back(blockName);
  1116.       blockName=strtok(NULL,"|");
  1117.     }
  1118.   
  1120.   if(in > 1 || out > 1)
  1121.     return; /* Invalid arguments */
  1122.   
  1123.   const MgmtSrvr::LogMode modes[] = {
  1124.     MgmtSrvr::Off,
  1125.     MgmtSrvr::Out,
  1126.     MgmtSrvr::In,
  1127.     MgmtSrvr::InOut,
  1128.   };
  1129.   MgmtSrvr::LogMode mode = modes[in<<1 | out];
  1131.   int result = m_mgmsrv.setSignalLoggingMode(node, mode, blocks);
  1133.   m_output->println("log signals reply");
  1134.   if(result != 0)
  1135.     m_output->println("result: %s", get_error_text(result));
  1136.   else
  1137.     m_output->println("result: Ok");
  1138.   m_output->println("");
  1139. }
  1141. void
  1142. MgmApiSession::start(Parser<MgmApiSession>::Context &,
  1143.      Properties const &args) {
  1144.   Uint32 node;
  1146.   args.get("node", &node);
  1147.   
  1148.   int result = m_mgmsrv.start(node);
  1150.   m_output->println("start reply");
  1151.   if(result != 0)
  1152.     m_output->println("result: %s", get_error_text(result));
  1153.   else
  1154.     m_output->println("result: Ok");
  1155.   m_output->println("");
  1156. }
  1158. void
  1159. MgmApiSession::startAll(Parser<MgmApiSession>::Context &,
  1160. Properties const &) {
  1161.   NodeId node = 0;
  1162.   int started = 0;
  1164.   while(m_mgmsrv.getNextNodeId(&node, NDB_MGM_NODE_TYPE_NDB))
  1165.     if(m_mgmsrv.start(node) == 0)
  1166.       started++;
  1168.   m_output->println("start reply");
  1169.   m_output->println("result: Ok");
  1170.   m_output->println("started: %d", started);
  1171.   m_output->println("");
  1172. }
  1174. void
  1175. MgmApiSession::setLogFilter(Parser_t::Context &ctx,
  1176.     const class Properties &args) {
  1177.   Uint32 level;
  1178.   Uint32 enable;
  1180.   args.get("level", &level);
  1181.   args.get("enable", &enable);
  1183.   int result = m_mgmsrv.setEventLogFilter(level, enable);
  1185.   m_output->println("set logfilter reply");
  1186.   m_output->println("result: %d", result);
  1187.   m_output->println("");
  1188. }
  1190. static NdbOut&
  1191. operator<<(NdbOut& out, const LogLevel & ll)
  1192. {
  1193.   out << "[LogLevel: ";
  1194.   for(size_t i = 0; i<LogLevel::LOGLEVEL_CATEGORIES; i++)
  1195.     out << ll.getLogLevel((LogLevel::EventCategory)i) << " ";
  1196.   out << "]";
  1197.   return out;
  1198. }
  1200. void
  1201. Ndb_mgmd_event_service::log(int eventType, const Uint32* theData, NodeId nodeId){
  1202.   
  1203.   Uint32 threshold;
  1204.   LogLevel::EventCategory cat;
  1205.   Logger::LoggerLevel severity;
  1206.   int i, n;
  1207.   DBUG_ENTER("Ndb_mgmd_event_service::log");
  1208.   DBUG_PRINT("enter",("eventType=%d, nodeid=%d", eventType, nodeId));
  1210.   if (EventLoggerBase::event_lookup(eventType,cat,threshold,severity))
  1211.     DBUG_VOID_RETURN;
  1213.   char m_text[256];
  1214.   EventLogger::getText(m_text, sizeof(m_text), eventType, theData, nodeId);
  1216.   Vector<NDB_SOCKET_TYPE> copy; 
  1217.   m_clients.lock();
  1218.   for(i = m_clients.size() - 1; i >= 0; i--)
  1219.   {
  1220.     if(threshold <= m_clients[i].m_logLevel.getLogLevel(cat))
  1221.     {
  1222.       int fd= m_clients[i].m_socket;
  1223.       if(fd != NDB_INVALID_SOCKET &&
  1224.  println_socket(fd, MAX_WRITE_TIMEOUT, m_text) == -1)
  1225.       {
  1226. copy.push_back(fd);
  1227. m_clients.erase(i, false);
  1228.       }
  1229.     }
  1230.   }
  1231.   m_clients.unlock();
  1232.   
  1233.   if ((n= (int)copy.size()))
  1234.   {
  1235.     for(i= 0; i < n; i++)
  1236.       NDB_CLOSE_SOCKET(copy[i]);
  1238.     LogLevel tmp; tmp.clear();
  1239.     m_clients.lock();
  1240.     for(i= m_clients.size() - 1; i >= 0; i--)
  1241.       tmp.set_max(m_clients[i].m_logLevel);
  1242.     m_clients.unlock();
  1243.     update_log_level(tmp);
  1244.   }
  1245.   DBUG_VOID_RETURN;
  1246. }
  1248. void
  1249. Ndb_mgmd_event_service::update_max_log_level(const LogLevel &log_level)
  1250. {
  1251.   LogLevel tmp= m_logLevel;
  1252.   tmp.set_max(log_level);
  1253.   update_log_level(tmp);
  1254. }
  1256. void
  1257. Ndb_mgmd_event_service::update_log_level(const LogLevel &tmp)
  1258. {
  1259.   if(!(tmp == m_logLevel)){
  1260.     m_logLevel = tmp;
  1261.     EventSubscribeReq req;
  1262.     req = tmp;
  1263.     req.blockRef = 0;
  1264.     m_mgmsrv->m_log_level_requests.push_back(req);
  1265.   }
  1266. }
  1268. void
  1269. Ndb_mgmd_event_service::check_listeners()
  1270. {
  1271.   int i, n= 0;
  1272.   DBUG_ENTER("Ndb_mgmd_event_service::check_listeners");
  1273.   m_clients.lock();
  1274.   for(i= m_clients.size() - 1; i >= 0; i--)
  1275.   {
  1276.     int fd= m_clients[i].m_socket;
  1277.     DBUG_PRINT("info",("%d %d",i,fd));
  1278.     char buf[1];
  1279.     buf[0]=0;
  1280.     if (fd != NDB_INVALID_SOCKET &&
  1281. println_socket(fd,MAX_WRITE_TIMEOUT,"<PING>") == -1)
  1282.     {
  1283.       NDB_CLOSE_SOCKET(fd);
  1284.       m_clients.erase(i, false);
  1285.       n=1;
  1286.     }
  1287.   }
  1288.   if (n)
  1289.   {
  1290.     LogLevel tmp; tmp.clear();
  1291.     for(i= m_clients.size() - 1; i >= 0; i--)
  1292.       tmp.set_max(m_clients[i].m_logLevel);
  1293.     update_log_level(tmp);
  1294.   }
  1295.   m_clients.unlock();
  1296.   DBUG_VOID_RETURN;
  1297. }
  1299. void
  1300. Ndb_mgmd_event_service::add_listener(const Event_listener& client)
  1301. {
  1302.   DBUG_ENTER("Ndb_mgmd_event_service::add_listener");
  1303.   DBUG_PRINT("enter",("client.m_socket: %d", client.m_socket));
  1305.   check_listeners();
  1307.   m_clients.push_back(client);
  1308.   update_max_log_level(client.m_logLevel);
  1310.   DBUG_VOID_RETURN;
  1311. }
  1313. void
  1314. Ndb_mgmd_event_service::stop_sessions(){
  1315.   m_clients.lock();
  1316.   for(int i = m_clients.size() - 1; i >= 0; i--){
  1317.     if(m_clients[i].m_socket != NDB_INVALID_SOCKET){
  1318.       NDB_CLOSE_SOCKET(m_clients[i].m_socket);
  1319.       m_clients.erase(i);
  1320.     }
  1321.   }
  1322.   m_clients.unlock();
  1323. }
  1325. void
  1326. MgmApiSession::setParameter(Parser_t::Context &,
  1327.     Properties const &args) {
  1328.   BaseString node, param, value;
  1329.   args.get("node", node);
  1330.   args.get("parameter", param);
  1331.   args.get("value", value);
  1332.   
  1333.   BaseString result;
  1334.   int ret = m_mgmsrv.setDbParameter(atoi(node.c_str()), 
  1335.     atoi(param.c_str()),
  1336.     value.c_str(),
  1337.     result);
  1338.   
  1339.   m_output->println("set parameter reply");
  1340.   m_output->println("message: %s", result.c_str());
  1341.   m_output->println("result: %d", ret);
  1342.   m_output->println("");
  1343. }
  1345. void
  1346. MgmApiSession::listen_event(Parser<MgmApiSession>::Context & ctx,
  1347.     Properties const & args) {
  1348.   
  1349.   BaseString node, param, value;
  1350.   args.get("node", node);
  1351.   args.get("filter", param);
  1353.   int result = 0;
  1354.   BaseString msg;
  1356.   Ndb_mgmd_event_service::Event_listener le;
  1357.   le.m_socket = m_socket;
  1359.   Vector<BaseString> list;
  1360.   param.trim();
  1361.   param.split(list, " ,");
  1362.   for(size_t i = 0; i<list.size(); i++){
  1363.     Vector<BaseString> spec;
  1364.     list[i].trim();
  1365.     list[i].split(spec, "=:");
  1366.     if(spec.size() != 2){
  1367.       msg.appfmt("Invalid filter specification: >%s< >%s< %d", 
  1368.  param.c_str(), list[i].c_str(), spec.size());
  1369.       result = -1;
  1370.       goto done;
  1371.     }
  1373.     spec[0].trim().ndb_toupper();
  1374.     int category = ndb_mgm_match_event_category(spec[0].c_str());
  1375.     if(category == NDB_MGM_ILLEGAL_EVENT_CATEGORY){
  1376.       category = atoi(spec[0].c_str());
  1377.       if(category < NDB_MGM_MIN_EVENT_CATEGORY ||
  1378.  category > NDB_MGM_MAX_EVENT_CATEGORY){
  1379. msg.appfmt("Unknown category: >%s<", spec[0].c_str());
  1380. result = -1;
  1381. goto done;
  1382.       }
  1383.     }
  1384.     
  1385.     int level = atoi(spec[1].c_str());
  1386.     if(level < 0 || level > 15){
  1387.       msg.appfmt("Invalid level: >%s<", spec[1].c_str());
  1388.       result = -1;
  1389.       goto done;
  1390.     }
  1391.     category -= CFG_MIN_LOGLEVEL;
  1392.     le.m_logLevel.setLogLevel((LogLevel::EventCategory)category, level);
  1393.   }
  1394.   
  1395.   if(list.size() == 0){
  1396.     msg.appfmt("Empty filter specification");
  1397.     result = -1;
  1398.     goto done;
  1399.   }
  1400.   
  1401.   m_mgmsrv.m_event_listner.add_listener(le);
  1402.   
  1403.   m_stop = true;
  1404.   m_socket = NDB_INVALID_SOCKET;
  1406. done:
  1407.   m_output->println("listen event");
  1408.   m_output->println("result: %d", result);
  1409.   if(result != 0)
  1410.     m_output->println("msg: %s", msg.c_str());
  1411.   m_output->println("");
  1412. }
  1414. struct PurgeStruct
  1415. {
  1416.   NodeBitmask free_nodes;/* free nodes as reported
  1417.   * by ndbd in apiRegReqConf
  1418.   */
  1419.   BaseString *str;
  1420. };
  1422. void
  1423. MgmApiSession::stop_session_if_not_connected(SocketServer::Session *_s, void *data)
  1424. {
  1425.   MgmApiSession *s= (MgmApiSession *)_s;
  1426.   struct PurgeStruct &ps= *(struct PurgeStruct *)data;
  1427.   if (s->m_allocated_resources->is_reserved(ps.free_nodes))
  1428.   {
  1429.     ps.str->appfmt(" %d", s->m_allocated_resources->get_nodeid());
  1430.     s->stopSession();
  1431.   }
  1432. }
  1434. void
  1435. MgmApiSession::purge_stale_sessions(Parser_t::Context &ctx,
  1436.     const class Properties &args)
  1437. {
  1438.   struct PurgeStruct ps;
  1439.   BaseString str;
  1440.   ps.str = &str;
  1442.   m_mgmsrv.get_connected_nodes(ps.free_nodes);
  1443.   ps.free_nodes.bitXORC(NodeBitmask()); // invert connected_nodes to get free nodes
  1445.   m_mgmsrv.get_socket_server()->foreachSession(stop_session_if_not_connected,&ps);
  1447.   m_output->println("purge stale sessions reply");
  1448.   if (str.length() > 0)
  1449.     m_output->println("purged:%s",str.c_str());
  1450.   m_output->println("result: Ok");
  1451.   m_output->println("");
  1452. }
  1454. void
  1455. MgmApiSession::check_connection(Parser_t::Context &ctx,
  1456. const class Properties &args)
  1457. {
  1458.   m_output->println("check connection reply");
  1459.   m_output->println("result: Ok");
  1460.   m_output->println("");
  1461. }
  1463. template class MutexVector<int>;
  1464. template class Vector<ParserRow<MgmApiSession> const*>;
  1465. template class Vector<unsigned short>;