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

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

MySQL数据库

开发平台：

Visual C++

CommandInterpreter.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. //#define HAVE_GLOBAL_REPLICATION
  22. #include <Vector.hpp>
  23. #ifdef  HAVE_GLOBAL_REPLICATION
  24. #include "../rep/repapi/repapi.h"
  25. #endif
  27. #include <mgmapi.h>
  29. class MgmtSrvr;
  31. /** 
  32.  *  @class CommandInterpreter
  33.  *  @brief Reads command line in management client
  34.  *
  35.  *  This class has one public method which reads a command line 
  36.  *  from a stream. It then interpret that commmand line and calls a suitable 
  37.  *  method in the MgmtSrvr class which executes the command.
  38.  *
  39.  *  For command syntax, see the HELP command.
  40.  */ 
  41. class CommandInterpreter {
  42. public:
  43.   /**
  44.    *   Constructor
  45.    *   @param mgmtSrvr: Management server to use when executing commands
  46.    */
  47.   CommandInterpreter(const char *, int verbose);
  48.   ~CommandInterpreter();
  49.   
  50.   /**
  51.    *   Reads one line from the stream, parse the line to find 
  52.    *   a command and then calls a suitable method which executes 
  53.    *   the command.
  54.    *
  55.    *   @return true until quit/bye/exit has been typed
  56.    */
  57.   int execute(const char *_line, int _try_reconnect=-1, int *error= 0);
  59. private:
  60.   void printError();
  61.   int execute_impl(const char *_line);
  63.   /**
  64.    *   Analyse the command line, after the first token.
  65.    *
  66.    *   @param  processId:           DB process id to send command to or -1 if
  67.    *                                command will be sent to all DB processes.
  68.    *   @param  allAfterFirstToken:  What the client gave after the 
  69.    *                                first token on the command line
  70.    */
  71.   void analyseAfterFirstToken(int processId, char* allAfterFirstTokenCstr);
  73.   /**
  74.    *   Parse the block specification part of the LOG* commands,
  75.    *   things after LOG*: [BLOCK = {ALL|<blockName>+}]
  76.    *
  77.    *   @param  allAfterLog: What the client gave after the second token 
  78.    *                        (LOG*) on the command line
  79.    *   @param  blocks, OUT: ALL or name of all the blocks
  80.    *   @return: true if correct syntax, otherwise false
  81.    */
  82.   bool parseBlockSpecification(const char* allAfterLog, 
  83.        Vector<const char*>& blocks);
  84.   
  85.   /**
  86.    *   A bunch of execute functions: Executes one of the commands
  87.    *
  88.    *   @param  processId:   DB process id to send command to
  89.    *   @param  parameters:  What the client gave after the command name 
  90.    *                        on the command line.
  91.    *   For example if complete input from user is: "1 LOGLEVEL 22" then the
  92.    *   parameters argument is the string with everything after LOGLEVEL, in
  93.    *   this case "22". Each function is responsible to check the parameters
  94.    *   argument.
  95.    */
  96.   void executeHelp(char* parameters);
  97.   void executeShow(char* parameters);
  98.   void executeConnect(char* parameters);
  99.   void executePurge(char* parameters);
  100.   int  executeShutdown(char* parameters);
  101.   void executeRun(char* parameters);
  102.   void executeInfo(char* parameters);
  103.   void executeClusterLog(char* parameters);
  105. public:
  106.   void executeStop(int processId, const char* parameters, bool all);
  107.   void executeEnterSingleUser(char* parameters);
  108.   void executeExitSingleUser(char* parameters);
  109.   void executeStart(int processId, const char* parameters, bool all);
  110.   void executeRestart(int processId, const char* parameters, bool all);
  111.   void executeLogLevel(int processId, const char* parameters, bool all);
  112.   void executeError(int processId, const char* parameters, bool all);
  113.   void executeLog(int processId, const char* parameters, bool all);
  114.   void executeLogIn(int processId, const char* parameters, bool all);
  115.   void executeLogOut(int processId, const char* parameters, bool all);
  116.   void executeLogOff(int processId, const char* parameters, bool all);
  117.   void executeTestOn(int processId, const char* parameters, bool all);
  118.   void executeTestOff(int processId, const char* parameters, bool all);
  119.   void executeSet(int processId, const char* parameters, bool all);
  120.   void executeGetStat(int processId, const char* parameters, bool all);
  121.   void executeStatus(int processId, const char* parameters, bool all);
  122.   void executeEventReporting(int processId, const char* parameters, bool all);
  123.   void executeDumpState(int processId, const char* parameters, bool all);
  124.   int executeStartBackup(char * parameters);
  125.   void executeAbortBackup(char * parameters);
  127.   void executeRep(char* parameters);
  129.   void executeCpc(char * parameters);
  131. public:
  132.   bool connect();
  133.   bool disconnect();
  135.   /**
  136.    * A execute function definition
  137.    */
  138. public:
  139.   typedef void (CommandInterpreter::* ExecuteFunction)(int processId, 
  140.        const char * param, 
  141.        bool all);
  142.   
  143.   struct CommandFunctionPair {
  144.     const char * command;
  145.     ExecuteFunction executeFunction;
  146.   };
  147. private:
  148.   /**
  149.    * 
  150.    */
  151.   void executeForAll(const char * cmd, 
  152.      ExecuteFunction fun,
  153.      const char * param);
  155.   NdbMgmHandle m_mgmsrv;
  156.   NdbMgmHandle m_mgmsrv2;
  157.   bool m_connected;
  158.   int m_verbose;
  159.   int try_reconnect;
  160.   int m_error;
  161. #ifdef HAVE_GLOBAL_REPLICATION  
  162.   NdbRepHandle m_repserver;
  163.   const char *rep_host;
  164.   bool rep_connected;
  165. #endif
  166.   struct NdbThread* m_event_thread;
  167. };
  170. /*
  171.  * Facade object for CommandInterpreter
  172.  */
  174. #include "ndb_mgmclient.hpp"
  175. #include "ndb_mgmclient.h"
  177. Ndb_mgmclient::Ndb_mgmclient(const char *host,int verbose)
  178. {
  179.   m_cmd= new CommandInterpreter(host,verbose);
  180. }
  181. Ndb_mgmclient::~Ndb_mgmclient()
  182. {
  183.   delete m_cmd;
  184. }
  185. int Ndb_mgmclient::execute(const char *_line, int _try_reconnect, int *error)
  186. {
  187.   return m_cmd->execute(_line,_try_reconnect,error);
  188. }
  189. int
  190. Ndb_mgmclient::disconnect()
  191. {
  192.   return m_cmd->disconnect();
  193. }
  195. extern "C" {
  196.   Ndb_mgmclient_handle ndb_mgmclient_handle_create(const char *connect_string)
  197.   {
  198.     return (Ndb_mgmclient_handle) new Ndb_mgmclient(connect_string);
  199.   }
  200.   int ndb_mgmclient_execute(Ndb_mgmclient_handle h, int argc, char** argv)
  201.   {
  202.     return ((Ndb_mgmclient*)h)->execute(argc, argv, 1);
  203.   }
  204.   int ndb_mgmclient_handle_destroy(Ndb_mgmclient_handle h)
  205.   {
  206.     delete (Ndb_mgmclient*)h;
  207.     return 0;
  208.   }
  209. }
  210. /*
  211.  * The CommandInterpreter
  212.  */
  214. #include <mgmapi.h>
  215. #include <mgmapi_debug.h>
  216. #include <version.h>
  217. #include <NdbAutoPtr.hpp>
  218. #include <NdbOut.hpp>
  219. #include <NdbSleep.h>
  220. #include <NdbMem.h>
  221. #include <EventLogger.hpp>
  222. #include <signaldata/SetLogLevelOrd.hpp>
  223. #include <signaldata/GrepImpl.hpp>
  224. #ifdef HAVE_GLOBAL_REPLICATION
  226. #endif // HAVE_GLOBAL_REPLICATION
  227. #include "MgmtErrorReporter.hpp"
  228. #include <Parser.hpp>
  229. #include <SocketServer.hpp>
  230. #include <util/InputStream.hpp>
  231. #include <util/OutputStream.hpp>
  233. int Ndb_mgmclient::execute(int argc, char** argv, int _try_reconnect, int *error)
  234. {
  235.   if (argc <= 0)
  236.     return 0;
  237.   BaseString _line(argv[0]);
  238.   for (int i= 1; i < argc; i++)
  239.   {
  240.     _line.appfmt(" %s", argv[i]);
  241.   }
  242.   return m_cmd->execute(_line.c_str(),_try_reconnect, error);
  243. }
  245. /*****************************************************************************
  246.  * HELP
  247.  *****************************************************************************/
  248. static const char* helpText =
  249. "---------------------------------------------------------------------------n"
  250. " NDB Cluster -- Management Client -- Helpn"
  251. "---------------------------------------------------------------------------n"
  252. "HELP                                   Print help textn"
  253. "HELP SHOW                              Help for SHOW commandn"
  254. #ifdef HAVE_GLOBAL_REPLICATION
  255. "HELP REPLICATION                       Help for global replicationn"
  256. #endif // HAVE_GLOBAL_REPLICATION
  257. #ifdef VM_TRACE // DEBUG ONLY
  258. "HELP DEBUG                             Help for debug compiled versionn"
  259. #endif
  260. "SHOW                                   Print information about clustern"
  261. #if 0
  262. "SHOW CONFIG                            Print configurationn"
  263. "SHOW PARAMETERS                        Print configuration parametersn"
  264. #endif
  265. "START BACKUP [NOWAIT | WAIT STARTED | WAIT COMPLETED]n"
  266. "                                       Start backup (default WAIT COMPLETED)n"
  267. "ABORT BACKUP <backup id>               Abort backupn"
  268. "SHUTDOWN                               Shutdown all processes in clustern"
  269. "CLUSTERLOG ON [<severity>] ...         Enable Cluster loggingn"
  270. "CLUSTERLOG OFF [<severity>] ...        Disable Cluster loggingn"
  271. "CLUSTERLOG TOGGLE [<severity>] ...     Toggle severity filter on/offn"
  272. "CLUSTERLOG INFO                        Print cluster log informationn"
  273. "<id> START                             Start DB node (started with -n)n"
  274. "<id> RESTART [-n] [-i]                 Restart DB noden"
  275. "<id> STOP                              Stop DB noden"
  276. "ENTER SINGLE USER MODE <api-node>      Enter single user moden"
  277. "EXIT SINGLE USER MODE                  Exit single user moden"
  278. "<id> STATUS                            Print statusn"
  279. "<id> CLUSTERLOG {<category>=<level>}+  Set log level for cluster logn"
  280. #ifdef HAVE_GLOBAL_REPLICATION
  281. "REP CONNECT <host:port>                Connect to REP server on host:portn"
  282. #endif
  283. "PURGE STALE SESSIONS                   Reset reserved nodeid's in the mgmt servern"
  284. "CONNECT [<connectstring>]              Connect to management server (reconnect if already connected)n"
  285. "QUIT                                   Quit management clientn"
  286. ;
  288. static const char* helpTextShow =
  289. "---------------------------------------------------------------------------n"
  290. " NDB Cluster -- Management Client -- Help for SHOW commandn"
  291. "---------------------------------------------------------------------------n"
  292. "SHOW prints NDB Cluster informationnn"
  293. "SHOW               Print information about clustern" 
  294. #if 0
  295. "SHOW CONFIG        Print configuration (in initial config file format)n" 
  296. "SHOW PARAMETERS    Print information about configuration parametersnn"
  297. #endif
  298. ;
  300. #ifdef HAVE_GLOBAL_REPLICATION
  301. static const char* helpTextRep =
  302. "---------------------------------------------------------------------------n"
  303. " NDB Cluster -- Management Client -- Help for Global Replicationn"
  304. "---------------------------------------------------------------------------n"
  305. "Commands should be executed on the standby NDB Clustern"
  306. "These features are in an experimental release state.n"
  307. "n"
  308. "Simple Commands:n"
  309. "REP START              Start Global Replicationn" 
  310. "REP START REQUESTOR    Start Global Replication Requestorn" 
  311. "REP STATUS             Show Global Replication statusn" 
  312. "REP STOP               Stop Global Replicationn"
  313. "REP STOP REQUESTOR     Stop Global Replication Requestorn"
  314. "n" 
  315. "Advanced Commands:n"
  316. "REP START <protocol>   Starts protocoln"
  317. "REP STOP <protocol>    Stops protocoln"
  318. "<protocol> = TRANSFER | APPLY | DELETEn"
  319. "n"
  320. #ifdef VM_TRACE // DEBUG ONLY
  321. "Debugging commands:n"
  322. "REP DELETE             Removes epochs stored in primary and standy systemsn"
  323. "REP DROP <tableid>     Drop a table in SS identified by table idn"
  324. "REP SLOWSTOP           Stop Replication (Tries to synchonize with primary)n" 
  325. "REP FASTSTOP           Stop Replication (Stops in consistent state)n" 
  326. "<component> = SUBSCRIPTIONn"
  327. "              METALOG | METASCAN | DATALOG | DATASCANn"
  328. "              REQUESTOR | TRANSFER | APPLY | DELETEn"
  329. #endif
  330. ;
  331. #endif // HAVE_GLOBAL_REPLICATION
  333. #ifdef VM_TRACE // DEBUG ONLY
  334. static const char* helpTextDebug =
  335. "---------------------------------------------------------------------------n"
  336. " NDB Cluster -- Management Client -- Help for Debugging (Internal use only)n"
  337. "---------------------------------------------------------------------------n"
  338. "SHOW PROPERTIES                       Print config properties objectn"
  339. "<id> LOGLEVEL {<category>=<level>}+   Set log leveln"
  340. #ifdef ERROR_INSERT
  341. "<id> ERROR <errorNo>                  Inject error into NDB noden"
  342. #endif
  343. "<id> LOG [BLOCK = {ALL|<block>+}]     Set logging on in & out signalsn"
  344. "<id> LOGIN [BLOCK = {ALL|<block>+}]   Set logging on in signalsn"
  345. "<id> LOGOUT [BLOCK = {ALL|<block>+}]  Set logging on out signalsn"
  346. "<id> LOGOFF [BLOCK = {ALL|<block>+}]  Unset signal loggingn"
  347. "<id> TESTON                           Start signal loggingn"
  348. "<id> TESTOFF                          Stop signal loggingn"
  349. "<id> SET <configParamName> <value>    Update configuration variablen"
  350. "<id> DUMP <arg>                       Dump system state to cluster.logn"
  351. "<id> GETSTAT                          Print statisticsn"
  352. "n"
  353. "<id>       = ALL | Any database node idn"
  354. ;
  355. #endif
  357. static bool
  358. convert(const char* s, int& val) {
  359.   
  360.   if (s == NULL)
  361.     return false;
  363.   if (strlen(s) == 0)
  364.     return false;
  366.   errno = 0;
  367.   char* p;
  368.   long v = strtol(s, &p, 10);
  369.   if (errno != 0)
  370.     return false;
  372.   if (p != &s[strlen(s)])
  373.     return false;
  374.   
  375.   val = v;
  376.   return true;
  377. }
  379. /*
  380.  * Constructor
  381.  */
  382. CommandInterpreter::CommandInterpreter(const char *_host,int verbose) 
  383.   : m_verbose(verbose)
  384. {
  385.   m_mgmsrv = ndb_mgm_create_handle();
  386.   if(m_mgmsrv == NULL) {
  387.     ndbout_c("Cannot create handle to management server.");
  388.     exit(-1);
  389.   }
  390.   m_mgmsrv2 = ndb_mgm_create_handle();
  391.   if(m_mgmsrv2 == NULL) {
  392.     ndbout_c("Cannot create handle to management server.");
  393.     exit(-1);
  394.   }
  395.   if (ndb_mgm_set_connectstring(m_mgmsrv, _host))
  396.   {
  397.     printError();
  398.     exit(-1);
  399.   }
  401.   m_connected= false;
  402.   m_event_thread= 0;
  403.   try_reconnect = 0;
  404. #ifdef HAVE_GLOBAL_REPLICATION
  405.   rep_host = NULL;
  406.   m_repserver = NULL;
  407.   rep_connected = false;
  408. #endif
  409. }
  411. /*
  412.  * Destructor
  413.  */
  414. CommandInterpreter::~CommandInterpreter() 
  415. {
  416.   disconnect();
  417.   ndb_mgm_destroy_handle(&m_mgmsrv);
  418.   ndb_mgm_destroy_handle(&m_mgmsrv2);
  419. }
  421. static bool 
  422. emptyString(const char* s) 
  423. {
  424.   if (s == NULL) {
  425.     return true;
  426.   }
  428.   for (unsigned int i = 0; i < strlen(s); ++i) {
  429.     if (! isspace(s[i])) {
  430.       return false;
  431.     }
  432.   }
  434.   return true;
  435. }
  437. void
  438. CommandInterpreter::printError() 
  439. {
  440.   if (ndb_mgm_check_connection(m_mgmsrv))
  441.   {
  442.     m_connected= false;
  443.     disconnect();
  444.   }
  445.   ndbout_c("* %5d: %s", 
  446.    ndb_mgm_get_latest_error(m_mgmsrv),
  447.    ndb_mgm_get_latest_error_msg(m_mgmsrv));
  448.   ndbout_c("*        %s", ndb_mgm_get_latest_error_desc(m_mgmsrv));
  449. }
  451. //*****************************************************************************
  452. //*****************************************************************************
  454. static int do_event_thread;
  455. static void*
  456. event_thread_run(void* m)
  457. {
  458.   DBUG_ENTER("event_thread_run");
  460.   NdbMgmHandle handle= *(NdbMgmHandle*)m;
  462.   int filter[] = { 15, NDB_MGM_EVENT_CATEGORY_BACKUP, 0 };
  463.   int fd = ndb_mgm_listen_event(handle, filter);
  464.   if (fd != NDB_INVALID_SOCKET)
  465.   {
  466.     do_event_thread= 1;
  467.     char *tmp= 0;
  468.     char buf[1024];
  469.     SocketInputStream in(fd,10);
  470.     do {
  471.       if (tmp == 0) NdbSleep_MilliSleep(10);
  472.       if((tmp = in.gets(buf, 1024)))
  473.       {
  474. const char ping_token[]= "<PING>";
  475. if (memcmp(ping_token,tmp,sizeof(ping_token)-1))
  476.   ndbout << tmp;
  477.       }
  478.     } while(do_event_thread);
  479.     NDB_CLOSE_SOCKET(fd);
  480.   }
  481.   else
  482.   {
  483.     do_event_thread= -1;
  484.   }
  486.   DBUG_RETURN(NULL);
  487. }
  489. bool
  490. CommandInterpreter::connect() 
  491. {
  492.   DBUG_ENTER("CommandInterpreter::connect");
  493.   if(!m_connected)
  494.   {
  495.     if(!ndb_mgm_connect(m_mgmsrv, try_reconnect-1, 5, 1))
  496.     {
  497.       const char *host= ndb_mgm_get_connected_host(m_mgmsrv);
  498.       unsigned port= ndb_mgm_get_connected_port(m_mgmsrv);
  499.       if(!ndb_mgm_set_connectstring(m_mgmsrv2,
  500.     BaseString(host).appfmt(":%d",port).c_str())
  501.  &&
  502.  !ndb_mgm_connect(m_mgmsrv2, try_reconnect-1, 5, 1))
  503.       {
  504. assert(m_event_thread == 0);
  505. assert(do_event_thread == 0);
  506. do_event_thread= 0;
  507. m_event_thread = NdbThread_Create(event_thread_run,
  508.   (void**)&m_mgmsrv2,
  509.   32768,
  510.   "CommandInterpreted_event_thread",
  511.   NDB_THREAD_PRIO_LOW);
  512. if (m_event_thread != 0)
  513. {
  514.   int iter= 1000; // try for 30 seconds
  515.   while(do_event_thread == 0 &&
  516. iter-- > 0)
  517.     NdbSleep_MilliSleep(30);
  518. }
  519. if (m_event_thread == 0 ||
  520.     do_event_thread == 0 ||
  521.     do_event_thread == -1)
  522. {
  523.   DBUG_PRINT("info",("Warning, event thread startup failed, "
  524.      "degraded printouts as result, errno=%d",
  525.      errno));
  526.   printf("Warning, event thread startup failed, "
  527.  "degraded printouts as result, errno=%dn", errno);
  528.   do_event_thread= 0;
  529.   if (m_event_thread)
  530.   {
  531.     void *res;
  532.     NdbThread_WaitFor(m_event_thread, &res);
  533.     NdbThread_Destroy(&m_event_thread);
  534.   }
  535.   ndb_mgm_disconnect(m_mgmsrv2);
  536. }
  537.       }
  538.       else
  539.       {
  540. printf("Warning, event connect failed, degraded printouts as resultn");
  541.       }
  542.       m_connected= true;
  543.       DBUG_PRINT("info",("Connected to Management Server at: %s:%d",
  544.  host,port));
  545.       if (m_verbose)
  546.       {
  547. printf("Connected to Management Server at: %s:%dn",
  548.        host, port);
  549.       }
  550.     }
  551.   }
  552.   DBUG_RETURN(m_connected);
  553. }
  555. bool 
  556. CommandInterpreter::disconnect() 
  557. {
  558.   DBUG_ENTER("CommandInterpreter::disconnect");
  559.   if (m_event_thread) {
  560.     void *res;
  561.     do_event_thread= 0;
  562.     NdbThread_WaitFor(m_event_thread, &res);
  563.     NdbThread_Destroy(&m_event_thread);
  564.     m_event_thread= 0;
  565.     ndb_mgm_disconnect(m_mgmsrv2);
  566.   }
  567.   if (m_connected)
  568.   {
  569.     if (ndb_mgm_disconnect(m_mgmsrv) == -1) {
  570.       ndbout_c("Could not disconnect from management server");
  571.       printError();
  572.     }
  573.     m_connected= false;
  574.   }
  575.   DBUG_RETURN(true);
  576. }
  578. //*****************************************************************************
  579. //*****************************************************************************
  581. int 
  582. CommandInterpreter::execute(const char *_line, int _try_reconnect,
  583.     int *error) 
  584. {
  585.   if (_try_reconnect >= 0)
  586.     try_reconnect=_try_reconnect;
  587.   int result= execute_impl(_line);
  588.   if (error)
  589.     *error= m_error;
  590.   return result;
  591. }
  593. static void
  594. invalid_command(const char *cmd)
  595. {
  596.   ndbout << "Invalid command: " << cmd << endl;
  597.   ndbout << "Type HELP for help." << endl << endl;
  598. }
  600. int 
  601. CommandInterpreter::execute_impl(const char *_line) 
  602. {
  603.   DBUG_ENTER("CommandInterpreter::execute_impl");
  604.   DBUG_PRINT("enter",("line="%s"",_line));
  605.   m_error= 0;
  607.   char * line;
  608.   if(_line == NULL) {
  609.     DBUG_RETURN(false);
  610.   }
  611.   line = my_strdup(_line,MYF(MY_WME));
  612.   My_auto_ptr<char> ptr(line);
  614.   int do_continue;
  615.   do {
  616.     do_continue= 0;
  617.     BaseString::trim(line," t");
  618.     if (line[0] == 0 ||
  619. line[0] == '#')
  620.     {
  621.       DBUG_RETURN(true);
  622.     }
  623.     // for mysql client compatability remove trailing ';'
  624.     {
  625.       unsigned last= strlen(line)-1;
  626.       if (line[last] == ';')
  627.       {
  628. line[last]= 0;
  629. do_continue= 1;
  630.       }
  631.     }
  632.   } while (do_continue);
  633.   // if there is anything in the line proceed
  634.   char* firstToken = strtok(line, " ");
  635.   char* allAfterFirstToken = strtok(NULL, "");
  636.   
  637.   if (strcasecmp(firstToken, "HELP") == 0 ||
  638.       strcasecmp(firstToken, "?") == 0) {
  639.     executeHelp(allAfterFirstToken);
  640.     DBUG_RETURN(true);
  641.   }
  642.   else if (strcasecmp(firstToken, "CONNECT") == 0) {
  643.     executeConnect(allAfterFirstToken);
  644.     DBUG_RETURN(true);
  645.   }
  646.   else if (strcasecmp(firstToken, "SLEEP") == 0) {
  647.     if (allAfterFirstToken)
  648.       sleep(atoi(allAfterFirstToken));
  649.     DBUG_RETURN(true);
  650.   }
  651.   else if((strcasecmp(firstToken, "QUIT") == 0 ||
  652.   strcasecmp(firstToken, "EXIT") == 0 ||
  653.   strcasecmp(firstToken, "BYE") == 0) && 
  654.   allAfterFirstToken == NULL){
  655.     DBUG_RETURN(false);
  656.   }
  658.   if (!connect())
  659.     DBUG_RETURN(true);
  661.   if (strcasecmp(firstToken, "SHOW") == 0) {
  662.     executeShow(allAfterFirstToken);
  663.     DBUG_RETURN(true);
  664.   }
  665.   else if (strcasecmp(firstToken, "SHUTDOWN") == 0) {
  666.     m_error= executeShutdown(allAfterFirstToken);
  667.     DBUG_RETURN(true);
  668.   }
  669.   else if (strcasecmp(firstToken, "CLUSTERLOG") == 0){
  670.     executeClusterLog(allAfterFirstToken);
  671.     DBUG_RETURN(true);
  672.   }
  673.   else if(strcasecmp(firstToken, "START") == 0 &&
  674.   allAfterFirstToken != NULL &&
  675.   strncasecmp(allAfterFirstToken, "BACKUP", sizeof("BACKUP") - 1) == 0){
  676.     m_error= executeStartBackup(allAfterFirstToken);
  677.     DBUG_RETURN(true);
  678.   }
  679.   else if(strcasecmp(firstToken, "ABORT") == 0 &&
  680.   allAfterFirstToken != NULL &&
  681.   strncasecmp(allAfterFirstToken, "BACKUP", sizeof("BACKUP") - 1) == 0){
  682.     executeAbortBackup(allAfterFirstToken);
  683.     DBUG_RETURN(true);
  684.   }
  685.   else if (strcasecmp(firstToken, "PURGE") == 0) {
  686.     executePurge(allAfterFirstToken);
  687.     DBUG_RETURN(true);
  688.   } 
  689. #ifdef HAVE_GLOBAL_REPLICATION
  690.   else if(strcasecmp(firstToken, "REPLICATION") == 0 ||
  691.   strcasecmp(firstToken, "REP") == 0) {
  692.     executeRep(allAfterFirstToken);
  693.     DBUG_RETURN(true);
  694.   }
  695. #endif // HAVE_GLOBAL_REPLICATION
  696.   else if(strcasecmp(firstToken, "ENTER") == 0 &&
  697.   allAfterFirstToken != NULL &&
  698.   strncasecmp(allAfterFirstToken, "SINGLE USER MODE ", 
  699.   sizeof("SINGLE USER MODE") - 1) == 0){
  700.     executeEnterSingleUser(allAfterFirstToken);
  701.     DBUG_RETURN(true);
  702.   }
  703.   else if(strcasecmp(firstToken, "EXIT") == 0 &&
  704.   allAfterFirstToken != NULL &&
  705.   strncasecmp(allAfterFirstToken, "SINGLE USER MODE ", 
  706.   sizeof("SINGLE USER MODE") - 1) == 0){
  707.     executeExitSingleUser(allAfterFirstToken);
  708.     DBUG_RETURN(true);
  709.   }
  710.   else if (strcasecmp(firstToken, "ALL") == 0) {
  711.     analyseAfterFirstToken(-1, allAfterFirstToken);
  712.   } else {
  713.     /**
  714.      * First token should be a digit, node ID
  715.      */
  716.     int nodeId;
  718.     if (! convert(firstToken, nodeId)) {
  719.       invalid_command(_line);
  720.       DBUG_RETURN(true);
  721.     }
  723.     if (nodeId <= 0) {
  724.       ndbout << "Invalid node ID: " << firstToken << "." << endl;
  725.       DBUG_RETURN(true);
  726.     }
  727.     
  728.     analyseAfterFirstToken(nodeId, allAfterFirstToken);
  729.     
  730.   }
  731.   DBUG_RETURN(true);
  732. }
  735. /**
  736.  * List of commands used as second command argument
  737.  */
  738. static const CommandInterpreter::CommandFunctionPair commands[] = {
  739.   { "START", &CommandInterpreter::executeStart }
  740.   ,{ "RESTART", &CommandInterpreter::executeRestart }
  741.   ,{ "STOP", &CommandInterpreter::executeStop }
  742.   ,{ "STATUS", &CommandInterpreter::executeStatus }
  743.   ,{ "LOGLEVEL", &CommandInterpreter::executeLogLevel }
  744.   ,{ "CLUSTERLOG", &CommandInterpreter::executeEventReporting }
  745. #ifdef ERROR_INSERT
  746.   ,{ "ERROR", &CommandInterpreter::executeError }
  747. #endif
  748.   ,{ "LOG", &CommandInterpreter::executeLog }
  749.   ,{ "LOGIN", &CommandInterpreter::executeLogIn }
  750.   ,{ "LOGOUT", &CommandInterpreter::executeLogOut }
  751.   ,{ "LOGOFF", &CommandInterpreter::executeLogOff }
  752.   ,{ "TESTON", &CommandInterpreter::executeTestOn }
  753.   ,{ "TESTOFF", &CommandInterpreter::executeTestOff }
  754.   ,{ "SET", &CommandInterpreter::executeSet }
  755.   ,{ "GETSTAT", &CommandInterpreter::executeGetStat }
  756.   ,{ "DUMP", &CommandInterpreter::executeDumpState }
  757. };
  760. //*****************************************************************************
  761. //*****************************************************************************
  762. void
  763. CommandInterpreter::analyseAfterFirstToken(int processId,
  764.    char* allAfterFirstToken) {
  765.   
  766.   if (emptyString(allAfterFirstToken)) {
  767.     ndbout << "Expected a command after "
  768.    << ((processId == -1) ? "ALL." : "node ID.") << endl;
  769.     return;
  770.   }
  771.   
  772.   char* secondToken = strtok(allAfterFirstToken, " ");
  773.   char* allAfterSecondToken = strtok(NULL, "");
  775.   const int tmpSize = sizeof(commands)/sizeof(CommandFunctionPair);
  776.   ExecuteFunction fun = 0;
  777.   const char * command = 0;
  778.   for(int i = 0; i<tmpSize; i++){
  779.     if(strcasecmp(secondToken, commands[i].command) == 0){
  780.       fun = commands[i].executeFunction;
  781.       command = commands[i].command;
  782.       break;
  783.     }
  784.   }
  785.   
  786.   if(fun == 0){
  787.     invalid_command(secondToken);
  788.     return;
  789.   }
  790.   
  791.   if(processId == -1){
  792.     executeForAll(command, fun, allAfterSecondToken);
  793.   } else {
  794.     (this->*fun)(processId, allAfterSecondToken, false);
  795.   }
  796.   ndbout << endl;
  797. }
  799. /**
  800.  * Get next nodeid larger than the give node_id. node_id will be
  801.  * set to the next node_id in the list. node_id should be set
  802.  * to 0 (zero) on the first call.
  803.  *
  804.  * @param handle the NDB management handle
  805.  * @param node_id last node_id retreived, 0 at first call
  806.  * @param type type of node to look for
  807.  * @return 1 if a node was found, 0 if no more node exist
  808.  */
  809. static 
  810. int 
  811. get_next_nodeid(struct ndb_mgm_cluster_state *cl,
  812. int *node_id,
  813. enum ndb_mgm_node_type type)
  814. {
  815.   int i;
  816.   
  817.   if(cl == NULL)
  818.     return 0;
  819.   
  820.   i=0;
  821.   while((i < cl->no_of_nodes)) {
  822.     if((*node_id < cl->node_states[i].node_id) &&
  823.        (cl->node_states[i].node_type == type)) {
  824.       
  825.       if(i >= cl->no_of_nodes)
  826. return 0;
  827.       
  828.       *node_id = cl->node_states[i].node_id;
  829.       return 1;
  830.     }
  831.     i++;
  832.   }
  833.   
  834.   return 0;
  835. }
  837. void
  838. CommandInterpreter::executeForAll(const char * cmd, ExecuteFunction fun, 
  839.   const char * allAfterSecondToken)
  840. {
  841.   int nodeId = 0;
  842.   if(strcasecmp(cmd, "STOP") == 0) {
  843.     ndbout_c("Executing STOP on all nodes.");
  844.     (this->*fun)(nodeId, allAfterSecondToken, true);
  845.   } else if(strcasecmp(cmd, "RESTART") == 0) {
  846.     ndbout_c("Executing RESTART on all nodes.");
  847.     ndbout_c("Starting shutdown. This may take a while. Please wait...");
  848.     (this->*fun)(nodeId, allAfterSecondToken, true);
  849.     ndbout_c("Trying to start all nodes of system.");
  850.     ndbout_c("Use ALL STATUS to see the system start-up phases.");
  851.   } else {
  852.     struct ndb_mgm_cluster_state *cl= ndb_mgm_get_status(m_mgmsrv);
  853.     if(cl == 0){
  854.       ndbout_c("Unable get status from management server");
  855.       printError();
  856.       return;
  857.     }
  858.     NdbAutoPtr<char> ap1((char*)cl);
  859.     while(get_next_nodeid(cl, &nodeId, NDB_MGM_NODE_TYPE_NDB))
  860.       (this->*fun)(nodeId, allAfterSecondToken, true);
  861.   }
  862. }
  864. //*****************************************************************************
  865. //*****************************************************************************
  866. bool 
  867. CommandInterpreter::parseBlockSpecification(const char* allAfterLog,
  868.     Vector<const char*>& blocks) 
  869. {
  870.   // Parse: [BLOCK = {ALL|<blockName>+}]
  872.   if (emptyString(allAfterLog)) {
  873.     return true;
  874.   }
  876.   // Copy allAfterLog since strtok will modify it  
  877.   char* newAllAfterLog = my_strdup(allAfterLog,MYF(MY_WME));
  878.   My_auto_ptr<char> ap1(newAllAfterLog);
  879.   char* firstTokenAfterLog = strtok(newAllAfterLog, " ");
  880.   for (unsigned int i = 0; i < strlen(firstTokenAfterLog); ++i) {
  881.     firstTokenAfterLog[i] = toupper(firstTokenAfterLog[i]);
  882.   }
  883.   
  884.   if (strcasecmp(firstTokenAfterLog, "BLOCK") != 0) {
  885.     ndbout << "Unexpected value: " << firstTokenAfterLog 
  886.    << ". Expected BLOCK." << endl;
  887.     return false;
  888.   }
  890.   char* allAfterFirstToken = strtok(NULL, "");
  891.   if (emptyString(allAfterFirstToken)) {
  892.     ndbout << "Expected =." << endl;
  893.     return false;
  894.   }
  896.   char* secondTokenAfterLog = strtok(allAfterFirstToken, " ");
  897.   if (strcasecmp(secondTokenAfterLog, "=") != 0) {
  898.     ndbout << "Unexpected value: " << secondTokenAfterLog 
  899.    << ". Expected =." << endl;
  900.     return false;
  901.   }
  903.   char* blockName = strtok(NULL, " ");
  904.   bool all = false;
  905.   if (blockName != NULL && (strcasecmp(blockName, "ALL") == 0)) {
  906.     all = true;
  907.   }
  908.   while (blockName != NULL) {
  909.     blocks.push_back(strdup(blockName));
  910.     blockName = strtok(NULL, " ");
  911.   }
  913.   if (blocks.size() == 0) {
  914.     ndbout << "No block specified." << endl;
  915.     return false;
  916.   }
  917.   if (blocks.size() > 1 && all) {
  918.     // More than "ALL" specified
  919.     ndbout << "Nothing expected after ALL." << endl;
  920.     return false;
  921.   }
  922.   
  923.   return true;
  924. }
  928. /*****************************************************************************
  929.  * HELP
  930.  *****************************************************************************/
  931. void 
  932. CommandInterpreter::executeHelp(char* parameters)
  933. {
  934.   if (emptyString(parameters)) {
  935.     ndbout << helpText;
  937.     ndbout << endl 
  938.    << "<severity> = " 
  939.    << "ALERT | CRITICAL | ERROR | WARNING | INFO | DEBUG"
  940.    << endl;
  942.     ndbout << "<category> = ";
  943.     for(int i = CFG_MIN_LOGLEVEL; i <= CFG_MAX_LOGLEVEL; i++){
  944.       const char *str= ndb_mgm_get_event_category_string((ndb_mgm_event_category)i);
  945.       if (str) {
  946. if (i != CFG_MIN_LOGLEVEL)
  947.   ndbout << " | ";
  948. ndbout << str;
  949.       }
  950.     }
  951.     ndbout << endl;
  953.     ndbout << "<level>    = " << "0 - 15" << endl;
  954.     ndbout << "<id>       = " << "ALL | Any database node id" << endl;
  955.     ndbout << endl;
  956.   } else if (strcasecmp(parameters, "SHOW") == 0) {
  957.     ndbout << helpTextShow;
  958. #ifdef HAVE_GLOBAL_REPLICATION
  959.   } else if (strcasecmp(parameters, "REPLICATION") == 0 ||
  960.      strcasecmp(parameters, "REP") == 0) {
  961.     ndbout << helpTextRep;
  962. #endif // HAVE_GLOBAL_REPLICATION
  963. #ifdef VM_TRACE // DEBUG ONLY
  964.   } else if (strcasecmp(parameters, "DEBUG") == 0) {
  965.     ndbout << helpTextDebug;
  966. #endif
  967.   } else {
  968.     invalid_command(parameters);
  969.   }
  970. }
  973. /*****************************************************************************
  974.  * SHUTDOWN
  975.  *****************************************************************************/
  977. int
  978. CommandInterpreter::executeShutdown(char* parameters) 
  979. { 
  980.   ndb_mgm_cluster_state *state = ndb_mgm_get_status(m_mgmsrv);
  981.   if(state == NULL) {
  982.     ndbout_c("Could not get status");
  983.     printError();
  984.     return 1;
  985.   }
  986.   NdbAutoPtr<char> ap1((char*)state);
  988.   int result = 0;
  989.   result = ndb_mgm_stop(m_mgmsrv, 0, 0);
  990.   if (result < 0) {
  991.     ndbout << "Shutdown off NDB Cluster storage node(s) failed." << endl;
  992.     printError();
  993.     return result;
  994.   }
  996.   ndbout << result << " NDB Cluster storage node(s) have shutdown." << endl;
  998.   int mgm_id= 0;
  999.   for(int i=0; i < state->no_of_nodes; i++) {
  1000.     if(state->node_states[i].node_type == NDB_MGM_NODE_TYPE_MGM &&
  1001.        state->node_states[i].version != 0){
  1002.       if (mgm_id == 0)
  1003. mgm_id= state->node_states[i].node_id;
  1004.       else {
  1005. ndbout << "Unable to locate management server, "
  1006.        << "shutdown manually with <id> STOP"
  1007.        << endl;
  1008. return 1;
  1009.       }
  1010.     }
  1011.   }
  1013.   result = ndb_mgm_stop(m_mgmsrv, 1, &mgm_id);
  1014.   if (result <= 0) {
  1015.     ndbout << "Shutdown of NDB Cluster management server failed." << endl;
  1016.     printError();
  1017.     if (result == 0)
  1018.       return 1;
  1019.     return result;
  1020.   }
  1022.   m_connected= false;
  1023.   disconnect();
  1024.   ndbout << "NDB Cluster management server shutdown." << endl;
  1025.   return 0;
  1026. }
  1028. /*****************************************************************************
  1029.  * SHOW
  1030.  *****************************************************************************/
  1033. static
  1034. const char *status_string(ndb_mgm_node_status status)
  1035. {
  1036.   switch(status){
  1037.   case NDB_MGM_NODE_STATUS_NO_CONTACT:
  1038.     return "not connected";
  1039.   case NDB_MGM_NODE_STATUS_NOT_STARTED:
  1040.     return "not started";
  1041.   case NDB_MGM_NODE_STATUS_STARTING:
  1042.     return "starting";
  1043.   case NDB_MGM_NODE_STATUS_STARTED:
  1044.     return "started";
  1045.   case NDB_MGM_NODE_STATUS_SHUTTING_DOWN:
  1046.     return "shutting down";
  1047.   case NDB_MGM_NODE_STATUS_RESTARTING:
  1048.     return "restarting";
  1049.   case NDB_MGM_NODE_STATUS_SINGLEUSER:
  1050.     return "single user mode";
  1051.   default:
  1052.     return "unknown state";
  1053.   }
  1054. }
  1056. static void
  1057. print_nodes(ndb_mgm_cluster_state *state, ndb_mgm_configuration_iterator *it,
  1058.     const char *proc_name, int no_proc, ndb_mgm_node_type type,
  1059.     int master_id)
  1060. { 
  1061.   int i;
  1062.   ndbout << "[" << proc_name
  1063.  << "(" << ndb_mgm_get_node_type_string(type) << ")]t"
  1064.  << no_proc << " node(s)" << endl;
  1065.   for(i=0; i < state->no_of_nodes; i++) {
  1066.     struct ndb_mgm_node_state *node_state= &(state->node_states[i]);
  1067.     if(node_state->node_type == type) {
  1068.       int node_id= node_state->node_id;
  1069.       ndbout << "id=" << node_id;
  1070.       if(node_state->version != 0) {
  1071. const char *hostname= node_state->connect_address;
  1072. if (hostname == 0
  1073.     || strlen(hostname) == 0
  1074.     || strcasecmp(hostname,"0.0.0.0") == 0)
  1075.   ndbout << " ";
  1076. else
  1077.   ndbout << "t@" << hostname;
  1078. ndbout << "  (Version: "
  1079.        << getMajor(node_state->version) << "."
  1080.        << getMinor(node_state->version) << "."
  1081.        << getBuild(node_state->version);
  1082. if (type == NDB_MGM_NODE_TYPE_NDB) {
  1083.   if (node_state->node_status != NDB_MGM_NODE_STATUS_STARTED) {
  1084.     ndbout << ", " << status_string(node_state->node_status);
  1085.   }
  1086.   if (node_state->node_group >= 0) {
  1087.     ndbout << ", Nodegroup: " << node_state->node_group;
  1088.     if (node_state->dynamic_id == master_id)
  1089.       ndbout << ", Master";
  1090.   }
  1091. }
  1092. ndbout << ")" << endl;
  1093.       } else {
  1094. ndb_mgm_first(it);
  1095. if(ndb_mgm_find(it, CFG_NODE_ID, node_id) == 0){
  1096.   const char *config_hostname= 0;
  1097.   ndb_mgm_get_string_parameter(it, CFG_NODE_HOST, &config_hostname);
  1098.   if (config_hostname == 0 || config_hostname[0] == 0)
  1099.     config_hostname= "any host";
  1100.   ndbout_c(" (not connected, accepting connect from %s)",
  1101.    config_hostname);
  1102. }
  1103. else
  1104. {
  1105.   ndbout_c("Unable to find node with id: %d", node_id);
  1106. }
  1107.       }
  1108.     }
  1109.   }
  1110.   ndbout << endl;
  1111. }
  1113. void
  1114. CommandInterpreter::executePurge(char* parameters) 
  1115. { 
  1116.   int command_ok= 0;
  1117.   do {
  1118.     if (emptyString(parameters))
  1119.       break;
  1120.     char* firstToken = strtok(parameters, " ");
  1121.     char* nextToken = strtok(NULL, " ");
  1122.     if (strcasecmp(firstToken,"STALE") == 0 &&
  1123. nextToken &&
  1124. strcasecmp(nextToken, "SESSIONS") == 0) {
  1125.       command_ok= 1;
  1126.       break;
  1127.     }
  1128.   } while(0);
  1130.   if (!command_ok) {
  1131.     ndbout_c("Unexpected command, expected: PURGE STALE SESSIONS");
  1132.     return;
  1133.   }
  1135.   int i;
  1136.   char *str;
  1137.   
  1138.   if (ndb_mgm_purge_stale_sessions(m_mgmsrv, &str)) {
  1139.     ndbout_c("Command failed");
  1140.     return;
  1141.   }
  1142.   if (str) {
  1143.     ndbout_c("Purged sessions with node id's: %s", str);
  1144.     free(str);
  1145.   }
  1146.   else
  1147.   {
  1148.     ndbout_c("No sessions purged");
  1149.   }
  1150. }
  1152. void
  1153. CommandInterpreter::executeShow(char* parameters) 
  1154. { 
  1155.   int i;
  1156.   if (emptyString(parameters)) {
  1157.     ndb_mgm_cluster_state *state = ndb_mgm_get_status(m_mgmsrv);
  1158.     if(state == NULL) {
  1159.       ndbout_c("Could not get status");
  1160.       printError();
  1161.       return;
  1162.     }
  1163.     NdbAutoPtr<char> ap1((char*)state);
  1165.     ndb_mgm_configuration * conf = ndb_mgm_get_configuration(m_mgmsrv,0);
  1166.     if(conf == 0){
  1167.       ndbout_c("Could not get configuration");
  1168.       printError();
  1169.       return;
  1170.     }
  1172.     ndb_mgm_configuration_iterator * it;
  1173.     it = ndb_mgm_create_configuration_iterator((struct ndb_mgm_configuration *)conf, CFG_SECTION_NODE);
  1175.     if(it == 0){
  1176.       ndbout_c("Unable to create config iterator");
  1177.       return;
  1178.     }
  1179.     NdbAutoPtr<ndb_mgm_configuration_iterator> ptr(it);
  1181.     int
  1182.       master_id= 0,
  1183.       ndb_nodes= 0,
  1184.       api_nodes= 0,
  1185.       mgm_nodes= 0;
  1187.     for(i=0; i < state->no_of_nodes; i++) {
  1188.       if(state->node_states[i].node_type == NDB_MGM_NODE_TYPE_NDB &&
  1189.  state->node_states[i].version != 0){
  1190. master_id= state->node_states[i].dynamic_id;
  1191. break;
  1192.       }
  1193.     }
  1194.     
  1195.     for(i=0; i < state->no_of_nodes; i++) {
  1196.       switch(state->node_states[i].node_type) {
  1197.       case NDB_MGM_NODE_TYPE_API:
  1198. api_nodes++;
  1199. break;
  1200.       case NDB_MGM_NODE_TYPE_NDB:
  1201. if (state->node_states[i].dynamic_id &&
  1202.     state->node_states[i].dynamic_id < master_id)
  1203.   master_id= state->node_states[i].dynamic_id;
  1204. ndb_nodes++;
  1205. break;
  1206.       case NDB_MGM_NODE_TYPE_MGM:
  1207. mgm_nodes++;
  1208. break;
  1209.       case NDB_MGM_NODE_TYPE_UNKNOWN:
  1210.         ndbout << "Error: Unknown Node Type" << endl;
  1211.         return;
  1212.       case NDB_MGM_NODE_TYPE_REP:
  1213. abort();
  1214.       }
  1215.     }
  1217.     ndbout << "Cluster Configuration" << endl
  1218.    << "---------------------" << endl;
  1219.     print_nodes(state, it, "ndbd",     ndb_nodes, NDB_MGM_NODE_TYPE_NDB, master_id);
  1220.     print_nodes(state, it, "ndb_mgmd", mgm_nodes, NDB_MGM_NODE_TYPE_MGM, 0);
  1221.     print_nodes(state, it, "mysqld",   api_nodes, NDB_MGM_NODE_TYPE_API, 0);
  1222.     //    ndbout << helpTextShow;
  1223.     return;
  1224.   } else if (strcasecmp(parameters, "PROPERTIES") == 0 ||
  1225.      strcasecmp(parameters, "PROP") == 0) {
  1226.     ndbout << "SHOW PROPERTIES is not yet implemented." << endl;
  1227.     //  ndbout << "_mgmtSrvr.getConfig()->print();" << endl; /* XXX */
  1228.   } else if (strcasecmp(parameters, "CONFIGURATION") == 0 ||
  1229.      strcasecmp(parameters, "CONFIG") == 0){
  1230.     ndbout << "SHOW CONFIGURATION is not yet implemented." << endl;
  1231.     //nbout << "_mgmtSrvr.getConfig()->printConfigFile();" << endl; /* XXX */
  1232.   } else if (strcasecmp(parameters, "PARAMETERS") == 0 ||
  1233.      strcasecmp(parameters, "PARAMS") == 0 ||
  1234.      strcasecmp(parameters, "PARAM") == 0) {
  1235.     ndbout << "SHOW PARAMETERS is not yet implemented." << endl;
  1236.     //    ndbout << "_mgmtSrvr.getConfig()->getConfigInfo()->print();" 
  1237.     //           << endl; /* XXX */
  1238.   } else {
  1239.     ndbout << "Invalid argument." << endl;
  1240.   }
  1241. }
  1243. void
  1244. CommandInterpreter::executeConnect(char* parameters) 
  1245. {
  1246.   disconnect();
  1247.   if (!emptyString(parameters)) {
  1248.     if (ndb_mgm_set_connectstring(m_mgmsrv,
  1249.   BaseString(parameters).trim().c_str()))
  1250.     {
  1251.       printError();
  1252.       return;
  1253.     }
  1254.   }
  1255.   connect();
  1256. }
  1258. //*****************************************************************************
  1259. //*****************************************************************************
  1260. void 
  1261. CommandInterpreter::executeClusterLog(char* parameters) 
  1262. {
  1263.   DBUG_ENTER("CommandInterpreter::executeClusterLog");
  1264.   int i;
  1265.   if (emptyString(parameters))
  1266.   {
  1267.     ndbout << "Missing argument." << endl;
  1268.     DBUG_VOID_RETURN;
  1269.   }
  1271.   enum ndb_mgm_clusterlog_level severity = NDB_MGM_CLUSTERLOG_ALL;
  1272.     
  1273.   char * tmpString = my_strdup(parameters,MYF(MY_WME));
  1274.   My_auto_ptr<char> ap1(tmpString);
  1275.   char * tmpPtr = 0;
  1276.   char * item = strtok_r(tmpString, " ", &tmpPtr);
  1277.   int enable;
  1279.   Uint32 *enabled = ndb_mgm_get_logfilter(m_mgmsrv);
  1280.   if(enabled == NULL) {
  1281.     ndbout << "Couldn't get status" << endl;
  1282.     printError();
  1283.     DBUG_VOID_RETURN;
  1284.   }
  1286.   /********************
  1287.    * CLUSTERLOG INFO
  1288.    ********************/
  1289.   if (strcasecmp(item, "INFO") == 0) {
  1290.     DBUG_PRINT("info",("INFO"));
  1291.     if(enabled[0] == 0)
  1292.     {
  1293.       ndbout << "Cluster logging is disabled." << endl;
  1294.       DBUG_VOID_RETURN;
  1295.     }
  1296. #if 0 
  1297.     for(i = 0; i<7;i++)
  1298.       printf("enabled[%d] = %dn", i, enabled[i]);
  1299. #endif
  1300.     ndbout << "Severities enabled: ";
  1301.     for(i = 1; i < (int)NDB_MGM_CLUSTERLOG_ALL; i++) {
  1302.       const char *str= ndb_mgm_get_clusterlog_level_string((ndb_mgm_clusterlog_level)i);
  1303.       if (str == 0)
  1304.       {
  1305. DBUG_ASSERT(false);
  1306. continue;
  1307.       }
  1308.       if(enabled[i])
  1309. ndbout << BaseString(str).ndb_toupper() << " ";
  1310.     }
  1311.     ndbout << endl;
  1312.     DBUG_VOID_RETURN;
  1314.   } 
  1315.   else if (strcasecmp(item, "FILTER") == 0 ||
  1316.    strcasecmp(item, "TOGGLE") == 0)
  1317.   {
  1318.     DBUG_PRINT("info",("TOGGLE"));
  1319.     enable= -1;
  1320.   } 
  1321.   else if (strcasecmp(item, "OFF") == 0) 
  1322.   {
  1323.     DBUG_PRINT("info",("OFF"));
  1324.     enable= 0;
  1325.   } else if (strcasecmp(item, "ON") == 0) {
  1326.     DBUG_PRINT("info",("ON"));
  1327.     enable= 1;
  1328.   } else {
  1329.     ndbout << "Invalid argument." << endl;
  1330.     DBUG_VOID_RETURN;
  1331.   }
  1333.   int res_enable;
  1334.   item = strtok_r(NULL, " ", &tmpPtr);
  1335.   if (item == NULL) {
  1336.     res_enable= ndb_mgm_filter_clusterlog(m_mgmsrv,
  1337.   NDB_MGM_CLUSTERLOG_ON, enable, NULL);
  1338.     if (res_enable < 0)
  1339.     {
  1340.       ndbout << "Couldn't set filter" << endl;
  1341.       printError();
  1342.       DBUG_VOID_RETURN;
  1343.     }
  1344.     ndbout << "Cluster logging is " << (res_enable ? "enabled.":"disabled") << endl;
  1345.     DBUG_VOID_RETURN;
  1346.   }
  1348.   do {
  1349.     severity= NDB_MGM_ILLEGAL_CLUSTERLOG_LEVEL;
  1350.     if (strcasecmp(item, "ALL") == 0) {
  1351.       severity = NDB_MGM_CLUSTERLOG_ALL;
  1352.     } else if (strcasecmp(item, "ALERT") == 0) {
  1353.       severity = NDB_MGM_CLUSTERLOG_ALERT;
  1354.     } else if (strcasecmp(item, "CRITICAL") == 0) { 
  1355.       severity = NDB_MGM_CLUSTERLOG_CRITICAL;
  1356.     } else if (strcasecmp(item, "ERROR") == 0) {
  1357.       severity = NDB_MGM_CLUSTERLOG_ERROR;
  1358.     } else if (strcasecmp(item, "WARNING") == 0) {
  1359.       severity = NDB_MGM_CLUSTERLOG_WARNING;
  1360.     } else if (strcasecmp(item, "INFO") == 0) {
  1361.       severity = NDB_MGM_CLUSTERLOG_INFO;
  1362.     } else if (strcasecmp(item, "DEBUG") == 0) {
  1363.       severity = NDB_MGM_CLUSTERLOG_DEBUG;
  1364.     } else if (strcasecmp(item, "OFF") == 0 ||
  1365.        strcasecmp(item, "ON") == 0) {
  1366.       if (enable < 0) // only makes sense with toggle
  1367. severity = NDB_MGM_CLUSTERLOG_ON;
  1368.     }
  1369.     if (severity == NDB_MGM_ILLEGAL_CLUSTERLOG_LEVEL) {
  1370.       ndbout << "Invalid severity level: " << item << endl;
  1371.       DBUG_VOID_RETURN;
  1372.     }
  1374.     res_enable = ndb_mgm_filter_clusterlog(m_mgmsrv, severity, enable, NULL);
  1375.     if (res_enable < 0)
  1376.     {
  1377.       ndbout << "Couldn't set filter" << endl;
  1378.       printError();
  1379.       DBUG_VOID_RETURN;
  1380.     }
  1381.     ndbout << BaseString(item).ndb_toupper().c_str() << " " << (res_enable ? "enabled":"disabled") << endl;
  1383.     item = strtok_r(NULL, " ", &tmpPtr);
  1384.   } while(item != NULL);
  1386.   DBUG_VOID_RETURN;
  1387. } 
  1389. //*****************************************************************************
  1390. //*****************************************************************************
  1392. void
  1393. CommandInterpreter::executeStop(int processId, const char *, bool all) 
  1394. {
  1395.   int result = 0;
  1396.   if(all) {
  1397.     result = ndb_mgm_stop(m_mgmsrv, 0, 0);
  1398.   } else {
  1399.     result = ndb_mgm_stop(m_mgmsrv, 1, &processId);
  1400.   }
  1401.   if (result < 0) {
  1402.     ndbout << "Shutdown failed." << endl;
  1403.     printError();
  1404.   } else
  1405.     {
  1406.       if(all)
  1407. ndbout << "NDB Cluster has shutdown." << endl;
  1408.       else
  1409. ndbout << "Node " << processId << " has shutdown." << endl;
  1410.     }
  1411. }
  1413. void
  1414. CommandInterpreter::executeEnterSingleUser(char* parameters) 
  1415. {
  1416.   strtok(parameters, " ");
  1417.   struct ndb_mgm_reply reply;
  1418.   char* id = strtok(NULL, " ");
  1419.   id = strtok(NULL, " ");
  1420.   id = strtok(NULL, "");
  1421.   int nodeId = -1;
  1422.   if(id == 0 || sscanf(id, "%d", &nodeId) != 1){
  1423.     ndbout_c("Invalid arguments: expected <NodeId>");
  1424.     ndbout_c("Use SHOW to see what API nodes are configured");
  1425.     return;
  1426.   }
  1427.   int result = ndb_mgm_enter_single_user(m_mgmsrv, nodeId, &reply);
  1428.   
  1429.   if (result != 0) {
  1430.     ndbout_c("Entering single user mode for node %d failed", nodeId);
  1431.     printError();
  1432.   } else {
  1433.     ndbout_c("Single user mode entered");
  1434.     ndbout_c("Access is granted for API node %d only.", nodeId);
  1435.   }
  1436. }
  1438. void 
  1439. CommandInterpreter::executeExitSingleUser(char* parameters) 
  1440. {
  1441.   int result = ndb_mgm_exit_single_user(m_mgmsrv, 0);
  1442.   if (result != 0) {
  1443.     ndbout_c("Exiting single user mode failed.");
  1444.     printError();
  1445.   } else {
  1446.     ndbout_c("Exiting single user mode in progress.");
  1447.     ndbout_c("Use ALL STATUS or SHOW to see when single user mode has been exited.");
  1448.   }
  1449. }
  1451. void
  1452. CommandInterpreter::executeStart(int processId, const char* parameters,
  1453.  bool all) 
  1454. {
  1455.   int result;
  1456.   if(all) {
  1457.     result = ndb_mgm_start(m_mgmsrv, 0, 0);
  1458.   } else {
  1459.     result = ndb_mgm_start(m_mgmsrv, 1, &processId);
  1460.   }
  1462.   if (result <= 0) {
  1463.     ndbout << "Start failed." << endl;
  1464.     printError();
  1465.   } else
  1466.     {
  1467.       if(all)
  1468. ndbout_c("NDB Cluster is being started.");
  1469.       else
  1470. ndbout_c("Database node %d is being started.", processId);
  1471.     }
  1472. }
  1474. void
  1475. CommandInterpreter::executeRestart(int processId, const char* parameters,
  1476.    bool all) 
  1477. {
  1478.   int result;
  1479.   int nostart = 0;
  1480.   int initialstart = 0;
  1481.   int abort = 0;
  1483.   if(parameters != 0 && strlen(parameters) != 0){
  1484.     char * tmpString = my_strdup(parameters,MYF(MY_WME));
  1485.     My_auto_ptr<char> ap1(tmpString);
  1486.     char * tmpPtr = 0;
  1487.     char * item = strtok_r(tmpString, " ", &tmpPtr);
  1488.     while(item != NULL){
  1489.       if(strcasecmp(item, "-N") == 0)
  1490. nostart = 1;
  1491.       if(strcasecmp(item, "-I") == 0)
  1492. initialstart = 1;
  1493.       if(strcasecmp(item, "-A") == 0)
  1494. abort = 1;
  1495.       item = strtok_r(NULL, " ", &tmpPtr);
  1496.     }
  1497.   }
  1499.   if(all) {
  1500.     result = ndb_mgm_restart2(m_mgmsrv, 0, NULL, initialstart, nostart, abort);
  1501.   } else {
  1502.     int v[1];
  1503.     v[0] = processId;
  1504.     result = ndb_mgm_restart2(m_mgmsrv, 1, v, initialstart, nostart, abort);
  1505.   }
  1506.   
  1507.   if (result <= 0) {
  1508.     ndbout.println("Restart failed.", result);
  1509.     printError();
  1510.   } else
  1511.     {
  1512.       if(all)
  1513. ndbout << "NDB Cluster is being restarted." << endl;
  1514.       else
  1515. ndbout_c("Node %d is being restarted.", processId);
  1516.     }
  1517. }
  1519. void
  1520. CommandInterpreter::executeDumpState(int processId, const char* parameters,
  1521.      bool all) 
  1522. {
  1523.   if(emptyString(parameters)){
  1524.     ndbout << "Expected argument" << endl;
  1525.     return;
  1526.   }
  1528.   Uint32 no = 0;
  1529.   int pars[25];
  1530.   
  1531.   char * tmpString = my_strdup(parameters,MYF(MY_WME));
  1532.   My_auto_ptr<char> ap1(tmpString);
  1533.   char * tmpPtr = 0;
  1534.   char * item = strtok_r(tmpString, " ", &tmpPtr);
  1535.   while(item != NULL){
  1536.     if (0x0 <= strtoll(item, NULL, 0) && strtoll(item, NULL, 0) <= 0xffffffff){
  1537.       pars[no] = strtoll(item, NULL, 0); 
  1538.     } else {
  1539.       ndbout << "Illegal value in argument to signal." << endl
  1540.      << "(Value must be between 0 and 0xffffffff.)" 
  1541.      << endl;
  1542.       return;
  1543.     }
  1544.     no++;
  1545.     item = strtok_r(NULL, " ", &tmpPtr);
  1546.   }
  1547.   ndbout << "Sending dump signal with data:" << endl;
  1548.   for (Uint32 i=0; i<no; i++) {
  1549.     ndbout.setHexFormat(1) << pars[i] << " ";
  1550.     if (!(i+1 & 0x3)) ndbout << endl;
  1551.   }
  1552.   
  1553.   struct ndb_mgm_reply reply;
  1554.   ndb_mgm_dump_state(m_mgmsrv, processId, pars, no, &reply);
  1555. }
  1557. void 
  1558. CommandInterpreter::executeStatus(int processId, 
  1559.   const char* parameters, bool all) 
  1560. {
  1561.   if (! emptyString(parameters)) {
  1562.     ndbout_c("No parameters expected to this command.");
  1563.     return;
  1564.   }
  1566.   ndb_mgm_node_status status;
  1567.   Uint32 startPhase, version;
  1568.   bool system;
  1569.   
  1570.   struct ndb_mgm_cluster_state *cl;
  1571.   cl = ndb_mgm_get_status(m_mgmsrv);
  1572.   if(cl == NULL) {
  1573.     ndbout_c("Cannot get status of node %d.", processId);
  1574.     printError();
  1575.     return;
  1576.   }
  1577.   NdbAutoPtr<char> ap1((char*)cl);
  1579.   int i = 0;
  1580.   while((i < cl->no_of_nodes) && cl->node_states[i].node_id != processId)
  1581.     i++;
  1582.   if(cl->node_states[i].node_id != processId) {
  1583.     ndbout << processId << ": Node not found" << endl;
  1584.     return;
  1585.   }
  1586.   status = cl->node_states[i].node_status;
  1587.   startPhase = cl->node_states[i].start_phase;
  1588.   version = cl->node_states[i].version;
  1590.   ndbout << "Node " << processId << ": " << status_string(status);
  1591.   switch(status){
  1592.   case NDB_MGM_NODE_STATUS_STARTING:
  1593.     ndbout << " (Phase " << startPhase << ")";
  1594.     break;
  1595.   case NDB_MGM_NODE_STATUS_SHUTTING_DOWN:
  1596.     ndbout << " (Phase " << startPhase << ")";
  1597.     break;
  1598.   default:
  1599.     break;
  1600.   }
  1601.   if(status != NDB_MGM_NODE_STATUS_NO_CONTACT)
  1602.     ndbout_c(" (Version %d.%d.%d)", 
  1603.      getMajor(version) ,
  1604.      getMinor(version),
  1605.      getBuild(version));
  1606.   else
  1607.     ndbout << endl;
  1608. }
  1611. //*****************************************************************************
  1612. //*****************************************************************************
  1614. void 
  1615. CommandInterpreter::executeLogLevel(int processId, const char* parameters, 
  1616.     bool all) 
  1617. {
  1618.   (void) all;
  1619.   if (emptyString(parameters)) {
  1620.     ndbout << "Expected argument" << endl;
  1621.     return;
  1622.   } 
  1623.   BaseString tmp(parameters);
  1624.   Vector<BaseString> spec;
  1625.   tmp.split(spec, "=");
  1626.   if(spec.size() != 2){
  1627.     ndbout << "Invalid loglevel specification: " << parameters << endl;
  1628.     return;
  1629.   }
  1631.   spec[0].trim().ndb_toupper();
  1632.   int category = ndb_mgm_match_event_category(spec[0].c_str());
  1633.   if(category == NDB_MGM_ILLEGAL_EVENT_CATEGORY){
  1634.     category = atoi(spec[0].c_str());
  1635.     if(category < NDB_MGM_MIN_EVENT_CATEGORY ||
  1636.        category > NDB_MGM_MAX_EVENT_CATEGORY){
  1637.       ndbout << "Unknown category: "" << spec[0].c_str() << """ << endl;
  1638.       return;
  1639.     }
  1640.   }
  1641.   
  1642.   int level = atoi(spec[1].c_str());
  1643.   if(level < 0 || level > 15){
  1644.     ndbout << "Invalid level: " << spec[1].c_str() << endl;
  1645.     return;
  1646.   }
  1647.   
  1648.   ndbout << "Executing LOGLEVEL on node " << processId << flush;
  1650.   struct ndb_mgm_reply reply;
  1651.   int result;
  1652.   result = ndb_mgm_set_loglevel_node(m_mgmsrv, 
  1653.      processId,
  1654.      (ndb_mgm_event_category)category,
  1655.      level, 
  1656.      &reply);
  1657.   
  1658.   if (result < 0) {
  1659.     ndbout_c(" failed.");
  1660.     printError();
  1661.   } else {
  1662.     ndbout_c(" OK!");
  1663.   }  
  1664.   
  1665. }
  1667. //*****************************************************************************
  1668. //*****************************************************************************
  1669. void CommandInterpreter::executeError(int processId, 
  1670.       const char* parameters, bool /* all */) 
  1671. {
  1672.   if (emptyString(parameters)) {
  1673.     ndbout << "Missing error number." << endl;
  1674.     return;
  1675.   }
  1677.   // Copy parameters since strtok will modify it
  1678.   char* newpar = my_strdup(parameters,MYF(MY_WME)); 
  1679.   My_auto_ptr<char> ap1(newpar);
  1680.   char* firstParameter = strtok(newpar, " ");
  1682.   int errorNo;
  1683.   if (! convert(firstParameter, errorNo)) {
  1684.     ndbout << "Expected an integer." << endl;
  1685.     return;
  1686.   }
  1688.   char* allAfterFirstParameter = strtok(NULL, "");
  1689.   if (! emptyString(allAfterFirstParameter)) {
  1690.     ndbout << "Nothing expected after error number." << endl;
  1691.     return;
  1692.   }
  1694.   ndb_mgm_insert_error(m_mgmsrv, processId, errorNo, NULL);
  1695. }
  1697. //*****************************************************************************
  1698. //*****************************************************************************
  1700. void 
  1701. CommandInterpreter::executeLog(int processId,
  1702.        const char* parameters, bool all) 
  1703. {
  1704.   struct ndb_mgm_reply reply;
  1705.   Vector<const char *> blocks;
  1706.   if (! parseBlockSpecification(parameters, blocks)) {
  1707.     return;
  1708.   }
  1709.   int len=1;
  1710.   Uint32 i;
  1711.   for(i=0; i<blocks.size(); i++) {
  1712.     len += strlen(blocks[i]) + 1;
  1713.   }
  1714.   char * blockNames = (char*)my_malloc(len,MYF(MY_WME));
  1715.   My_auto_ptr<char> ap1(blockNames);
  1716.   
  1717.   blockNames[0] = 0;
  1718.   for(i=0; i<blocks.size(); i++) {
  1719.     strcat(blockNames, blocks[i]);
  1720.     strcat(blockNames, "|");
  1721.   }
  1722.   
  1723.   int result = ndb_mgm_log_signals(m_mgmsrv,
  1724.    processId, 
  1725.    NDB_MGM_SIGNAL_LOG_MODE_INOUT, 
  1726.    blockNames,
  1727.    &reply);
  1728.   if (result != 0) {
  1729.     ndbout_c("Execute LOG on node %d failed.", processId);
  1730.     printError();
  1731.   }
  1732. }
  1734. //*****************************************************************************
  1735. //*****************************************************************************
  1736. void 
  1737. CommandInterpreter::executeLogIn(int /* processId */,
  1738.  const char* parameters, bool /* all */) 
  1739. {
  1740.   ndbout << "Command LOGIN not implemented." << endl;
  1741. }
  1743. //*****************************************************************************
  1744. //*****************************************************************************
  1745. void 
  1746. CommandInterpreter::executeLogOut(int /*processId*/, 
  1747.   const char* parameters, bool /*all*/) 
  1748. {
  1749.   ndbout << "Command LOGOUT not implemented." << endl;
  1750. }
  1752. //*****************************************************************************
  1753. //*****************************************************************************
  1754. void 
  1755. CommandInterpreter::executeLogOff(int /*processId*/,
  1756.   const char* parameters, bool /*all*/) 
  1757. {
  1758.   ndbout << "Command LOGOFF not implemented." << endl;
  1759. }
  1761. //*****************************************************************************
  1762. //*****************************************************************************
  1763. void 
  1764. CommandInterpreter::executeTestOn(int processId,
  1765.   const char* parameters, bool /*all*/) 
  1766. {
  1767.   if (! emptyString(parameters)) {
  1768.     ndbout << "No parameters expected to this command." << endl;
  1769.     return;
  1770.   }
  1771.   struct ndb_mgm_reply reply;
  1772.   int result = ndb_mgm_start_signallog(m_mgmsrv, processId, &reply);
  1773.   if (result != 0) {
  1774.     ndbout_c("Execute TESTON failed.");
  1775.     printError();
  1776.   }
  1777. }
  1779. //*****************************************************************************
  1780. //*****************************************************************************
  1781. void 
  1782. CommandInterpreter::executeTestOff(int processId,
  1783.    const char* parameters, bool /*all*/) 
  1784. {
  1785.   if (! emptyString(parameters)) {
  1786.     ndbout << "No parameters expected to this command." << endl;
  1787.     return;
  1788.   }
  1789.   struct ndb_mgm_reply reply;
  1790.   int result = ndb_mgm_stop_signallog(m_mgmsrv, processId, &reply);
  1791.   if (result != 0) {
  1792.     ndbout_c("Execute TESTOFF failed.");
  1793.     printError();
  1794.   }
  1795. }
  1798. //*****************************************************************************
  1799. //*****************************************************************************
  1800. void 
  1801. CommandInterpreter::executeSet(int /*processId*/, 
  1802.        const char* parameters, bool /*all*/) 
  1803. {
  1804.   if (emptyString(parameters)) {
  1805.     ndbout << "Missing parameter name." << endl;
  1806.     return;
  1807.   }
  1808. #if 0
  1809.   // Copy parameters since strtok will modify it
  1810.   char* newpar = my_strdup(parameters,MYF(MY_WME));
  1811.   My_auto_ptr<char> ap1(newpar);
  1812.   char* configParameterName = strtok(newpar, " ");
  1814.   char* allAfterParameterName = strtok(NULL, "");
  1815.   if (emptyString(allAfterParameterName)) {
  1816.     ndbout << "Missing parameter value." << endl;
  1817.     return;
  1818.   }
  1820.   char* value = strtok(allAfterParameterName, " ");
  1822.   char* allAfterValue = strtok(NULL, "");
  1823.   if (! emptyString(allAfterValue)) {
  1824.     ndbout << "Nothing expected after parameter value." << endl;
  1825.     return;
  1826.   }
  1828.   bool configBackupFileUpdated;
  1829.   bool configPrimaryFileUpdated;
  1830.   
  1831.   // TODO The handling of the primary and backup config files should be 
  1832.   // analysed further.
  1833.   // How it should be handled if only the backup is possible to write.
  1835.   int result = _mgmtSrvr.updateConfigParam(processId, configParameterName, 
  1836.    value, configBackupFileUpdated, 
  1837.    configPrimaryFileUpdated);
  1838.   if (result == 0) {
  1839.     if (configBackupFileUpdated && configPrimaryFileUpdated) {
  1840.       ndbout << "The configuration is updated." << endl;
  1841.     }
  1842.     else if (configBackupFileUpdated && !configPrimaryFileUpdated) {
  1843.       ndbout << "The configuration is updated but it was only possible " 
  1844.      << "to update the backup configuration file, not the primary." 
  1845.      << endl;
  1846.     }
  1847.     else {
  1848.       assert(false);
  1849.     }
  1850.   }
  1851.   else {
  1852.     ndbout << get_error_text(result) << endl;
  1853.     if (configBackupFileUpdated && configPrimaryFileUpdated) {
  1854.       ndbout << "The configuration files are however updated and "
  1855.      << "the value will be used next time the process is restarted." 
  1856.      << endl;
  1857.     }
  1858.     else if (configBackupFileUpdated && !configPrimaryFileUpdated) {
  1859.       ndbout << "It was only possible to update the backup "
  1860.      << "configuration file, not the primary." << endl;
  1861.     }
  1862.     else if (!configBackupFileUpdated && !configPrimaryFileUpdated) {
  1863.       ndbout << "The configuration files are not updated." << endl;
  1864.     }
  1865.     else {
  1866.       // The primary is not tried to write if the write of backup file fails
  1867.       abort();
  1868.     }
  1869.   }
  1870. #endif
  1871. }
  1873. //*****************************************************************************
  1874. //*****************************************************************************
  1875. void CommandInterpreter::executeGetStat(int /*processId*/,
  1876. const char* parameters, bool /*all*/) 
  1877. {
  1878.   if (! emptyString(parameters)) {
  1879.     ndbout << "No parameters expected to this command." << endl;
  1880.     return;
  1881.   }
  1883. #if 0
  1884.   MgmtSrvr::Statistics statistics;
  1885.   int result = _mgmtSrvr.getStatistics(processId, statistics);
  1886.   if (result != 0) {
  1887.     ndbout << get_error_text(result) << endl;
  1888.     return;
  1889.   }
  1890. #endif
  1891.   // Print statistic...
  1892.   /*
  1893.   ndbout << "Number of GETSTAT commands: " 
  1894.   << statistics._test1 << endl;
  1895.   */
  1896. }
  1898. //*****************************************************************************
  1899. //*****************************************************************************
  1900.  
  1901. void 
  1902. CommandInterpreter::executeEventReporting(int processId,
  1903.   const char* parameters, 
  1904.   bool all) 
  1905. {
  1906.   if (emptyString(parameters)) {
  1907.     ndbout << "Expected argument" << endl;
  1908.     return;
  1909.   }
  1910.   BaseString tmp(parameters);
  1911.   Vector<BaseString> specs;
  1912.   tmp.split(specs, " ");
  1914.   for (int i=0; i < specs.size(); i++)
  1915.   {
  1916.     Vector<BaseString> spec;
  1917.     specs[i].split(spec, "=");
  1918.     if(spec.size() != 2){
  1919.       ndbout << "Invalid loglevel specification: " << specs[i] << endl;
  1920.       continue;
  1921.     }
  1923.     spec[0].trim().ndb_toupper();
  1924.     int category = ndb_mgm_match_event_category(spec[0].c_str());
  1925.     if(category == NDB_MGM_ILLEGAL_EVENT_CATEGORY){
  1926.       if(!convert(spec[0].c_str(), category) ||
  1927.  category < NDB_MGM_MIN_EVENT_CATEGORY ||
  1928.  category > NDB_MGM_MAX_EVENT_CATEGORY){
  1929. ndbout << "Unknown category: "" << spec[0].c_str() << """ << endl;
  1930. continue;
  1931.       }
  1932.     }
  1934.     int level;
  1935.     if (!convert(spec[1].c_str(),level))
  1936.     {
  1937.       ndbout << "Invalid level: " << spec[1].c_str() << endl;
  1938.       continue;
  1939.     }
  1941.     ndbout << "Executing CLUSTERLOG " << spec[0] << "=" << spec[1]
  1942.    << " on node " << processId << flush;
  1944.     struct ndb_mgm_reply reply;
  1945.     int result;
  1946.     result = ndb_mgm_set_loglevel_clusterlog(m_mgmsrv, 
  1947.      processId,
  1948.      (ndb_mgm_event_category)category,
  1949.      level, 
  1950.      &reply);
  1951.   
  1952.     if (result != 0) {
  1953.       ndbout_c(" failed."); 
  1954.       printError();
  1955.     } else {
  1956.       ndbout_c(" OK!"); 
  1957.     }
  1958.   }
  1959. }
  1961. /*****************************************************************************
  1962.  * Backup
  1963.  *****************************************************************************/
  1964. int
  1965. CommandInterpreter::executeStartBackup(char* parameters)
  1966. {
  1967.   struct ndb_mgm_reply reply;
  1968.   unsigned int backupId;
  1969. #if 0
  1970.   int filter[] = { 15, NDB_MGM_EVENT_CATEGORY_BACKUP, 0 };
  1971.   int fd = ndb_mgm_listen_event(m_mgmsrv, filter);
  1972.   if (fd < 0)
  1973.   {
  1974.     ndbout << "Initializing start of backup failed" << endl;
  1975.     printError();
  1976.     return fd;
  1977.   }
  1978. #endif
  1979.   Vector<BaseString> args;
  1980.   {
  1981.     BaseString(parameters).split(args);
  1982.     for (unsigned i= 0; i < args.size(); i++)
  1983.       if (args[i].length() == 0)
  1984. args.erase(i--);
  1985.       else
  1986. args[i].ndb_toupper();
  1987.   }
  1988.   int sz= args.size();
  1990.   int result;
  1991.   if (sz == 2 &&
  1992.       args[1] == "NOWAIT")
  1993.   {
  1994.     result = ndb_mgm_start_backup(m_mgmsrv, 0, &backupId, &reply);
  1995.   }
  1996.   else if (sz == 1 ||
  1997.    (sz == 3 &&
  1998.     args[1] == "WAIT" &&
  1999.     args[2] == "COMPLETED"))
  2000.   {
  2001.     ndbout_c("Waiting for completed, this may take several minutes");
  2002.     result = ndb_mgm_start_backup(m_mgmsrv, 2, &backupId, &reply);
  2003.   }
  2004.   else if (sz == 3 &&
  2005.    args[1] == "WAIT" &&
  2006.    args[2] == "STARTED")
  2007.   {
  2008.     ndbout_c("Waiting for started, this may take several minutes");
  2009.     result = ndb_mgm_start_backup(m_mgmsrv, 1, &backupId, &reply);
  2010.   }
  2011.   else
  2012.   {
  2013.     invalid_command(parameters);
  2014.     return -1;
  2015.   }
  2017.   if (result != 0) {
  2018.     ndbout << "Start of backup failed" << endl;
  2019.     printError();
  2020. #if 0
  2021.     close(fd);
  2022. #endif
  2023.     return result;
  2024.   }
  2025. #if 0
  2026.   ndbout_c("Waiting for completed, this may take several minutes");
  2027.   char *tmp;
  2028.   char buf[1024];
  2029.   {
  2030.     SocketInputStream in(fd);
  2031.     int count = 0;
  2032.     do {
  2033.       tmp = in.gets(buf, 1024);
  2034.       if(tmp)
  2035.       {
  2036. ndbout << tmp;
  2037. unsigned int id;
  2038. if(sscanf(tmp, "%*[^:]: Backup %d ", &id) == 1 && id == backupId){
  2039.   count++;
  2040. }
  2041.       }
  2042.     } while(count < 2);
  2043.   }
  2045.   SocketInputStream in(fd, 10);
  2046.   do {
  2047.     tmp = in.gets(buf, 1024);
  2048.     if(tmp && tmp[0] != 0)
  2049.     {
  2050.       ndbout << tmp;
  2051.     }
  2052.   } while(tmp && tmp[0] != 0);
  2054.   close(fd);
  2055. #endif  
  2056.   return 0;
  2057. }
  2059. void
  2060. CommandInterpreter::executeAbortBackup(char* parameters) 
  2061. {
  2062.   int bid = -1;
  2063.   struct ndb_mgm_reply reply;
  2064.   if (emptyString(parameters))
  2065.     goto executeAbortBackupError1;
  2067.   {
  2068.     strtok(parameters, " ");
  2069.     char* id = strtok(NULL, "");
  2070.     if(id == 0 || sscanf(id, "%d", &bid) != 1)
  2071.       goto executeAbortBackupError1;
  2072.   }
  2073.   {
  2074.     int result= ndb_mgm_abort_backup(m_mgmsrv, bid, &reply);
  2075.     if (result != 0) {
  2076.       ndbout << "Abort of backup " << bid << " failed" << endl;
  2077.       printError();
  2078.     } else {
  2079.       ndbout << "Abort of backup " << bid << " ordered" << endl;
  2080.     }
  2081.   }
  2082.   return;
  2083.  executeAbortBackupError1:
  2084.   ndbout << "Invalid arguments: expected <BackupId>" << endl;
  2085.   return;
  2086. }
  2088. #ifdef HAVE_GLOBAL_REPLICATION
  2089. /*****************************************************************************
  2090.  * Global Replication
  2091.  *
  2092.  * For information about the different commands, see
  2093.  * GrepReq::Request in file signaldata/grepImpl.cpp.
  2094.  *
  2095.  * Below are commands as of 2003-07-05 (may change!):
  2096.  * START = 0,            ///< Start Global Replication (all phases)
  2097.  * START_METALOG = 1,    ///< Start Global Replication (all phases)
  2098.  * START_METASCAN = 2,   ///< Start Global Replication (all phases)
  2099.  * START_DATALOG = 3,    ///< Start Global Replication (all phases)
  2100.  * START_DATASCAN = 4,   ///< Start Global Replication (all phases)
  2101.  * START_REQUESTOR = 5,  ///< Start Global Replication (all phases)
  2102.  * ABORT = 6,            ///< Immediate stop (removes subscription)
  2103.  * SLOW_STOP = 7,        ///< Stop after finishing applying current GCI epoch
  2104.  * FAST_STOP = 8,        ///< Stop after finishing applying all PS GCI epochs
  2105.  * START_TRANSFER = 9,   ///< Start SS-PS transfer
  2106.  * STOP_TRANSFER = 10,   ///< Stop SS-PS transfer
  2107.  * START_APPLY = 11,     ///< Start applying GCI epochs in SS
  2108.  * STOP_APPLY = 12,      ///< Stop applying GCI epochs in SS
  2109.  * STATUS = 13,           ///< Status
  2110.  * START_SUBSCR = 14,
  2111.  * REMOVE_BUFFERS = 15,
  2112.  * DROP_TABLE = 16
  2114.  *****************************************************************************/
  2116. void
  2117. CommandInterpreter::executeRep(char* parameters) 
  2118. {
  2119.   if (emptyString(parameters)) {
  2120.     ndbout << helpTextRep;
  2121.     return;
  2122.   }
  2124.   char * line = my_strdup(parameters,MYF(MY_WME));
  2125.   My_auto_ptr<char> ap1((char*)line);
  2126.   char * firstToken = strtok(line, " ");
  2127.   
  2128.   struct ndb_rep_reply  reply;
  2129.   unsigned int          repId;
  2132.   if (!strcasecmp(firstToken, "CONNECT")) {
  2133.     char * host = strtok(NULL, "");
  2134.     for (unsigned int i = 0; i < strlen(host); ++i) {
  2135.       host[i] = tolower(host[i]);
  2136.     }
  2137.     
  2138.     if(host == NULL)
  2139.     {
  2140.       ndbout_c("host:port must be specified.");
  2141.       return;
  2142.     }
  2143.     
  2144.     if(rep_connected) {
  2145.       if(m_repserver != NULL) {
  2146. ndb_rep_disconnect(m_repserver);
  2147. rep_connected = false;
  2148.       }       
  2149.     }
  2150.           
  2151.     if(m_repserver == NULL)
  2152.       m_repserver = ndb_rep_create_handle();
  2153.     if(ndb_rep_connect(m_repserver, host) < 0)
  2154.       ndbout_c("Failed to connect to %s", host); 
  2155.     else
  2156.       rep_connected=true;
  2157.     return;
  2158.     
  2159.     if(!rep_connected) {
  2160.       ndbout_c("Not connected to REP server");
  2161.     }
  2162.   }
  2163.     
  2164.   /********
  2165.    * START 
  2166.    ********/
  2167.   if (!strcasecmp(firstToken, "START")) {
  2168.     
  2169.     unsigned int          req;
  2170.     char *startType = strtok(NULL, "");
  2171.     
  2172.     if (startType == NULL) {                
  2173.       req = GrepReq::START;
  2174.     } else if (!strcasecmp(startType, "SUBSCRIPTION")) {  
  2175.       req = GrepReq::START_SUBSCR;
  2176.     } else if (!strcasecmp(startType, "METALOG")) { 
  2177.       req = GrepReq::START_METALOG;
  2178.     } else if (!strcasecmp(startType, "METASCAN")) {
  2179.       req = GrepReq::START_METASCAN;
  2180.     } else if (!strcasecmp(startType, "DATALOG")) {
  2181.       req = GrepReq::START_DATALOG;
  2182.     } else if (!strcasecmp(startType, "DATASCAN")) {
  2183.       req = GrepReq::START_DATASCAN;
  2184.     } else if (!strcasecmp(startType, "REQUESTOR")) {
  2185.       req = GrepReq::START_REQUESTOR;
  2186.     } else if (!strcasecmp(startType, "TRANSFER")) {
  2187.       req = GrepReq::START_TRANSFER;
  2188.     } else if (!strcasecmp(startType, "APPLY")) {
  2189.       req = GrepReq::START_APPLY;
  2190.     } else if (!strcasecmp(startType, "DELETE")) {
  2191.       req = GrepReq::START_DELETE;
  2192.     } else {
  2193.       ndbout_c("Illegal argument to command 'REPLICATION START'");
  2194.       return;
  2195.     }
  2197.     int result = ndb_rep_command(m_repserver, req, &repId, &reply);
  2198.     
  2199.     if (result != 0) {
  2200.       ndbout << "Start of Global Replication failed" << endl;
  2201.     } else {
  2202.       ndbout << "Start of Global Replication ordered" << endl;
  2203.     }
  2204.     return;
  2205.   }
  2207.   /********
  2208.    * STOP
  2209.    ********/
  2210.   if (!strcasecmp(firstToken, "STOP")) {    
  2211.     unsigned int          req;
  2212.     char *startType = strtok(NULL, " ");
  2213.     unsigned int epoch = 0;
  2214.     
  2215.     if (startType == NULL) {                 
  2216.       /**
  2217.        * Stop immediately
  2218.        */
  2219.       req = GrepReq::STOP;
  2220.     } else if (!strcasecmp(startType, "EPOCH")) {  
  2221.       char *strEpoch = strtok(NULL, "");
  2222.       if(strEpoch == NULL) {
  2223. ndbout_c("Epoch expected!");
  2224. return;
  2225.       }
  2226.       req = GrepReq::STOP;
  2227.       epoch=atoi(strEpoch);      
  2228.     } else if (!strcasecmp(startType, "SUBSCRIPTION")) {  
  2229.       req = GrepReq::STOP_SUBSCR;
  2230.     } else if (!strcasecmp(startType, "METALOG")) { 
  2231.       req = GrepReq::STOP_METALOG;
  2232.     } else if (!strcasecmp(startType, "METASCAN")) {
  2233.       req = GrepReq::STOP_METASCAN;
  2234.     } else if (!strcasecmp(startType, "DATALOG")) {
  2235.       req = GrepReq::STOP_DATALOG;
  2236.     } else if (!strcasecmp(startType, "DATASCAN")) {
  2237.       req = GrepReq::STOP_DATASCAN;
  2238.     } else if (!strcasecmp(startType, "REQUESTOR")) {
  2239.       req = GrepReq::STOP_REQUESTOR;
  2240.     } else if (!strcasecmp(startType, "TRANSFER")) {
  2241.       req = GrepReq::STOP_TRANSFER;
  2242.     } else if (!strcasecmp(startType, "APPLY")) {
  2243.       req = GrepReq::STOP_APPLY;
  2244.     } else if (!strcasecmp(startType, "DELETE")) {
  2245.       req = GrepReq::STOP_DELETE;
  2246.     } else {
  2247.       ndbout_c("Illegal argument to command 'REPLICATION STOP'");
  2248.       return;
  2249.     }
  2250.     int result = ndb_rep_command(m_repserver, req, &repId, &reply, epoch);
  2251.     
  2252.     if (result != 0) {
  2253.       ndbout << "Stop command failed" << endl;
  2254.     } else {
  2255.       ndbout << "Stop ordered" << endl;
  2256.     }
  2257.     return;
  2258.   }
  2260.   /*********
  2261.    * STATUS
  2262.    *********/
  2263.   if (!strcasecmp(firstToken, "STATUS")) {
  2264.     struct rep_state repstate;
  2265.     int result = 
  2266.       ndb_rep_get_status(m_repserver, &repId, &reply, &repstate);
  2267.     
  2268.     if (result != 0) {
  2269.       ndbout << "Status request of Global Replication failed" << endl;
  2270.     } else {
  2271.       ndbout << "Status request of Global Replication ordered" << endl;
  2272.       ndbout << "See printout at one of the DB nodes" << endl;
  2273.       ndbout << "(Better status report is under development.)" << endl;
  2274.       ndbout << " SubscriptionId " << repstate.subid 
  2275.      << " SubscriptionKey " << repstate.subkey << endl;
  2276.     }
  2277.     return;
  2278.   }
  2280.   /*********
  2281.    * QUERY (see repapi.h for querable counters)
  2282.    *********/
  2283.   if (!strcasecmp(firstToken, "QUERY")) {
  2284.     char *query = strtok(NULL, "");
  2285.     int queryCounter=-1;
  2286.     if(query != NULL) {
  2287.       queryCounter = atoi(query);
  2288.     }
  2289.     struct rep_state repstate;
  2290.     unsigned repId = 0;
  2291.     int result = ndb_rep_query(m_repserver, (QueryCounter)queryCounter,
  2292.        &repId, &reply, &repstate);
  2293.     
  2294.     if (result != 0) {
  2295.       ndbout << "Query repserver failed" << endl;
  2296.     } else {
  2297.       ndbout << "Query repserver sucessful" << endl;
  2298.       ndbout_c("repstate : QueryCounter %d, f=%d l=%d"
  2299.        " nodegroups %d" , 
  2300.        repstate.queryCounter,
  2301.        repstate.first[0], repstate.last[0],
  2302.        repstate.no_of_nodegroups );
  2303.     }
  2304.     return;
  2305.   }
  2306. }
  2307. #endif // HAVE_GLOBAL_REPLICATION
  2309. template class Vector<char const*>;