mgmapi.h
上传用户:romrleung
上传日期:2022-05-23
资源大小:18897k
文件大小:26k
源码类别:

MySQL数据库

开发平台:

Visual C++

  1. /* Copyright (C) 2003 MySQL AB
  2.    This program is free software; you can redistribute it and/or modify
  3.    it under the terms of the GNU General Public License as published by
  4.    the Free Software Foundation; either version 2 of the License, or
  5.    (at your option) any later version.
  6.    This program is distributed in the hope that it will be useful,
  7.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  8.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  9.    GNU General Public License for more details.
  10.    You should have received a copy of the GNU General Public License
  11.    along with this program; if not, write to the Free Software
  12.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  13. #ifndef MGMAPI_H
  14. #define MGMAPI_H
  15. /**
  16.  * @mainpage NDB Cluster Management API
  17.  *
  18.  * The NDB Cluster Management API (MGM API) is a C API 
  19.  * that is used to:
  20.  * - Start/stop database nodes (DB nodes)
  21.  * - Start/stop NDB Cluster backups
  22.  * - Control the NDB Cluster log
  23.  * - Other administrative tasks
  24.  *
  25.  * @section  General Concepts
  26.  *
  27.  * Each MGM API function needs a management server handle 
  28.  * (of type Mgm_C_Api::NdbMgmHandle).  
  29.  * This handle is initally is created by calling the 
  30.  * function ndb_mgm_create_handle().
  31.  *
  32.  * A function can return:
  33.  *  -# An integer value.  
  34.  *     If it returns -1 then this indicates an error, and then
  35.  *  -# A pointer value.  If it returns NULL then check the latest error.
  36.  *     If it didn't return NULL, then a "something" is returned.
  37.  *     This "something" has to be free:ed by the user of the MGM API.
  38.  *
  39.  * If there are an error, then the get latest error functions
  40.  * can be used to check what the error was.
  41.  */
  42. /** @addtogroup MGM_C_API
  43.  *  @{
  44.  */
  45. #include <stdio.h>
  46. #include <ndb_types.h>
  47. #include "mgmapi_config_parameters.h"
  48. #ifdef __cplusplus
  49. extern "C" {
  50. #endif
  51.   /**
  52.    * The NdbMgmHandle.
  53.    */
  54.   typedef struct ndb_mgm_handle * NdbMgmHandle;
  55.   /**
  56.    *   NDB Cluster node types
  57.    */
  58.   enum ndb_mgm_node_type {
  59.     NDB_MGM_NODE_TYPE_UNKNOWN = -1,           /*< Node type not known*/
  60.     NDB_MGM_NODE_TYPE_API     = NODE_TYPE_API,/*< An application node (API)*/
  61.     NDB_MGM_NODE_TYPE_NDB     = NODE_TYPE_DB, /*< A database node (DB)*/
  62.     NDB_MGM_NODE_TYPE_MGM     = NODE_TYPE_MGM,/*< A mgmt server node (MGM)*/
  63.     NDB_MGM_NODE_TYPE_REP     = NODE_TYPE_REP,/*< A replication node */
  64.     NDB_MGM_NODE_TYPE_MIN     = 0,            /*< Min valid value*/
  65.     NDB_MGM_NODE_TYPE_MAX     = 3             /*< Max valid value*/
  66.   };
  67.   /**
  68.    *   Database node status
  69.    */
  70.   enum ndb_mgm_node_status {
  71.     NDB_MGM_NODE_STATUS_UNKNOWN       = 0,  /*< Node status not known*/
  72.     NDB_MGM_NODE_STATUS_NO_CONTACT    = 1,  /*< No contact with node*/
  73.     NDB_MGM_NODE_STATUS_NOT_STARTED   = 2,  /*< Has not run starting protocol*/
  74.     NDB_MGM_NODE_STATUS_STARTING      = 3,  /*< Is running starting protocol*/
  75.     NDB_MGM_NODE_STATUS_STARTED       = 4,  /*< Running*/
  76.     NDB_MGM_NODE_STATUS_SHUTTING_DOWN = 5,  /*< Is shutting down*/
  77.     NDB_MGM_NODE_STATUS_RESTARTING    = 6,  /*< Is restarting*/
  78.     NDB_MGM_NODE_STATUS_SINGLEUSER    = 7,  /*< Maintenance mode*/
  79.     NDB_MGM_NODE_STATUS_RESUME        = 8,  /*< Resume mode*/
  80.     NDB_MGM_NODE_STATUS_MIN           = 0,  /*< Min valid value*/
  81.     NDB_MGM_NODE_STATUS_MAX           = 6   /*< Max valid value*/
  82.   };
  83.   /**
  84.    *    Error codes
  85.    */
  86.   enum ndb_mgm_error {
  87.     NDB_MGM_NO_ERROR = 0,
  88.     /* Request for service errors */
  89.     NDB_MGM_ILLEGAL_CONNECT_STRING = 1001,
  90.     NDB_MGM_ILLEGAL_PORT_NUMBER = 1002,
  91.     NDB_MGM_ILLEGAL_SOCKET = 1003,
  92.     NDB_MGM_ILLEGAL_IP_ADDRESS = 1004,
  93.     NDB_MGM_ILLEGAL_SERVER_HANDLE = 1005,
  94.     NDB_MGM_ILLEGAL_SERVER_REPLY = 1006,
  95.     NDB_MGM_ILLEGAL_NUMBER_OF_NODES = 1007,
  96.     NDB_MGM_ILLEGAL_NODE_STATUS = 1008,
  97.     NDB_MGM_OUT_OF_MEMORY = 1009,
  98.     NDB_MGM_SERVER_NOT_CONNECTED = 1010,
  99.     NDB_MGM_COULD_NOT_CONNECT_TO_SOCKET = 1011,
  100.     /* Service errors - Start/Stop Node or System */
  101.     NDB_MGM_START_FAILED = 2001,
  102.     NDB_MGM_STOP_FAILED = 2002,
  103.     NDB_MGM_RESTART_FAILED = 2003,
  104.     /* Service errors - Backup */
  105.     NDB_MGM_COULD_NOT_START_BACKUP = 3001,
  106.     NDB_MGM_COULD_NOT_ABORT_BACKUP = 3002,
  107.     /* Service errors - Single User Mode */
  108.     NDB_MGM_COULD_NOT_ENTER_SINGLE_USER_MODE = 4001,
  109.     NDB_MGM_COULD_NOT_EXIT_SINGLE_USER_MODE = 4002,
  110.     /* Usage errors */
  111.     NDB_MGM_USAGE_ERROR = 5001
  112.   };
  113.   struct Ndb_Mgm_Error_Msg {
  114.     enum ndb_mgm_error  code;
  115.     const char *        msg; 
  116.   };
  117.   const struct Ndb_Mgm_Error_Msg ndb_mgm_error_msgs[] = {
  118.     { NDB_MGM_NO_ERROR, "No error" },
  119.     { NDB_MGM_ILLEGAL_CONNECT_STRING, "Illegal connect string" },
  120.     { NDB_MGM_ILLEGAL_PORT_NUMBER, "Illegal port number" },
  121.     { NDB_MGM_ILLEGAL_SOCKET, "Illegal socket" },
  122.     { NDB_MGM_ILLEGAL_IP_ADDRESS, "Illegal IP address" },
  123.     { NDB_MGM_ILLEGAL_SERVER_HANDLE, "Illegal server handle" },
  124.     { NDB_MGM_ILLEGAL_SERVER_REPLY, "Illegal reply from server" },
  125.     { NDB_MGM_ILLEGAL_NUMBER_OF_NODES, "Illegal number of nodes" },
  126.     { NDB_MGM_ILLEGAL_NODE_STATUS, "Illegal node status" },
  127.     { NDB_MGM_OUT_OF_MEMORY, "Out of memory" },
  128.     { NDB_MGM_SERVER_NOT_CONNECTED, "Management server not connected" },
  129.     { NDB_MGM_COULD_NOT_CONNECT_TO_SOCKET, "Could not connect to socket" },
  130.     /* Service errors - Start/Stop Node or System */
  131.     { NDB_MGM_START_FAILED, "Start failed" },
  132.     { NDB_MGM_STOP_FAILED, "Stop failed" },
  133.     { NDB_MGM_RESTART_FAILED, "Restart failed" },
  134.     /* Service errors - Backup */
  135.     { NDB_MGM_COULD_NOT_START_BACKUP, "Could not start backup" },
  136.     { NDB_MGM_COULD_NOT_ABORT_BACKUP, "Could not abort backup" },
  137.     
  138.     /* Service errors - Single User Mode */
  139.     { NDB_MGM_COULD_NOT_ENTER_SINGLE_USER_MODE, 
  140.       "Could not enter single user mode" },
  141.     { NDB_MGM_COULD_NOT_EXIT_SINGLE_USER_MODE, 
  142.       "Could not exit single user mode" },
  143.     /* Usage errors */
  144.     { NDB_MGM_USAGE_ERROR,
  145.       "Usage error" }
  146.   };
  147.   
  148.   const int ndb_mgm_noOfErrorMsgs = 
  149.   sizeof(ndb_mgm_error_msgs)/sizeof(struct Ndb_Mgm_Error_Msg);
  150.   /**
  151.    *   Structure returned by ndb_mgm_get_status
  152.    */
  153.   struct ndb_mgm_node_state {
  154.     int node_id;                            /*< NDB Cluster node id*/
  155.     enum ndb_mgm_node_type   node_type;     /*< Type of NDB Cluster node*/
  156.     enum ndb_mgm_node_status node_status;   /*< State of node*/
  157.     int start_phase;                        /*< Start phase.
  158.      *< @note Start phase is only
  159.      *< valid if
  160.      *< node_type is
  161.      *< NDB_MGM_NODE_TYPE_NDB and
  162.      *< node_status is
  163.      *< NDB_MGM_NODE_STATUS_STARTING
  164.      */
  165.     int dynamic_id;                         /*< Id for heartbeats and
  166.      *< master take-over
  167.      *< (only valid for DB nodes)
  168.      */
  169.     int node_group;                         /*< Node group of node
  170.      *< (only valid for DB nodes)*/
  171.     int version;                            /*< Internal version number*/
  172.     int connect_count;                      /*< No of times node has connected
  173.      *< or disconnected to the mgm srv
  174.      */
  175.     char connect_address[sizeof("000.000.000.000")+1];
  176.   };
  177.   /**
  178.    *   Cluster status
  179.    */
  180.   struct ndb_mgm_cluster_state {
  181.     int no_of_nodes;                        /*< No of entries in the 
  182.      *< node_states array
  183.      */
  184.     struct ndb_mgm_node_state               /*< An array with node_states*/
  185.     node_states[1];
  186.     const char *hostname;
  187.   };
  188.   /**
  189.    *   Default reply from the server
  190.    */
  191.   struct ndb_mgm_reply {
  192.     int return_code;                        /*< 0 if successful, 
  193.      *< otherwise error code.
  194.      */
  195.     char message[256];                      /*< Error or reply message.*/
  196.   };
  197.   /**
  198.    *   Default information types
  199.    */
  200.   enum ndb_mgm_info {
  201.     NDB_MGM_INFO_CLUSTER,                   /*< ?*/
  202.     NDB_MGM_INFO_CLUSTERLOG                 /*< Cluster log*/
  203.   };
  204.   /**
  205.    *   Signal log modes
  206.    *   (Used only in the development of NDB Cluster.)
  207.    */
  208.   enum ndb_mgm_signal_log_mode {
  209.     NDB_MGM_SIGNAL_LOG_MODE_IN,             /*< Log receiving signals */
  210.     NDB_MGM_SIGNAL_LOG_MODE_OUT,            /*< Log sending signals*/
  211.     NDB_MGM_SIGNAL_LOG_MODE_INOUT,          /*< Log both sending/receiving*/
  212.     NDB_MGM_SIGNAL_LOG_MODE_OFF             /*< Log off*/
  213.   };
  214.   /**
  215.    *   Log severities (used to filter the cluster log)
  216.    */
  217.   enum ndb_mgm_clusterlog_level {
  218.     NDB_MGM_ILLEGAL_CLUSTERLOG_LEVEL = -1,
  219.     /* must range from 0 and up, indexes into an array */
  220.     NDB_MGM_CLUSTERLOG_ON    = 0,           /*< Cluster log on*/
  221.     NDB_MGM_CLUSTERLOG_DEBUG = 1,           /*< Used in NDB Cluster
  222.      *< developement
  223.      */
  224.     NDB_MGM_CLUSTERLOG_INFO = 2,            /*< Informational messages*/
  225.     NDB_MGM_CLUSTERLOG_WARNING = 3,         /*< Conditions that are not
  226.      *< error condition, but 
  227.      *< might require handling
  228.      */
  229.     NDB_MGM_CLUSTERLOG_ERROR = 4,           /*< Conditions that should be
  230.      *< corrected
  231.      */
  232.     NDB_MGM_CLUSTERLOG_CRITICAL = 5,        /*< Critical conditions, like
  233.      *< device errors or out of 
  234.      *< resources
  235.      */
  236.     NDB_MGM_CLUSTERLOG_ALERT = 6,           /*< A condition that should be
  237.      *< corrected immediately,
  238.      *< such as a corrupted system
  239.      */
  240.     /* must be next number, works as bound in loop */
  241.     NDB_MGM_CLUSTERLOG_ALL = 7              /*< All severities */
  242.   };
  243.   /**
  244.    *   Log categories
  245.    */
  246.   enum ndb_mgm_event_category {
  247.     /**
  248.      * Invalid
  249.      */
  250.     NDB_MGM_ILLEGAL_EVENT_CATEGORY = -1,
  251.     /**
  252.      * Events during all kinds of startups
  253.      */
  254.     NDB_MGM_EVENT_CATEGORY_STARTUP = CFG_LOGLEVEL_STARTUP,
  255.     
  256.     /**
  257.      * Events during shutdown
  258.      */
  259.     NDB_MGM_EVENT_CATEGORY_SHUTDOWN = CFG_LOGLEVEL_SHUTDOWN,
  260.     /**
  261.      * Transaction statistics (Job level, TCP/IP speed)
  262.      */
  263.     NDB_MGM_EVENT_CATEGORY_STATISTIC = CFG_LOGLEVEL_STATISTICS,
  264.     NDB_MGM_EVENT_CATEGORY_CHECKPOINT = CFG_LOGLEVEL_CHECKPOINT,
  265.     NDB_MGM_EVENT_CATEGORY_NODE_RESTART = CFG_LOGLEVEL_NODERESTART,
  266.     NDB_MGM_EVENT_CATEGORY_CONNECTION = CFG_LOGLEVEL_CONNECTION,
  267.     NDB_MGM_EVENT_CATEGORY_DEBUG = CFG_LOGLEVEL_DEBUG,
  268.     NDB_MGM_EVENT_CATEGORY_INFO = CFG_LOGLEVEL_INFO,
  269.     NDB_MGM_EVENT_CATEGORY_WARNING = CFG_LOGLEVEL_WARNING,
  270.     NDB_MGM_EVENT_CATEGORY_ERROR = CFG_LOGLEVEL_ERROR,
  271.     NDB_MGM_EVENT_CATEGORY_GREP = CFG_LOGLEVEL_GREP,
  272.     NDB_MGM_EVENT_CATEGORY_BACKUP = CFG_LOGLEVEL_BACKUP,
  273.     
  274.     NDB_MGM_MIN_EVENT_CATEGORY = CFG_MIN_LOGLEVEL,
  275.     NDB_MGM_MAX_EVENT_CATEGORY = CFG_MAX_LOGLEVEL
  276.   };
  277.   
  278.   /***************************************************************************/
  279.   /** 
  280.    * @name Functions: Error Handling
  281.    * @{
  282.    */
  283.   /**
  284.    * Get latest error associated with a management server handle
  285.    *
  286.    * @param   handle        Management handle
  287.    * @return                Latest error code
  288.    */
  289.   int ndb_mgm_get_latest_error(const NdbMgmHandle handle);
  290.   /**
  291.    * Get latest main error message associated with a handle
  292.    *
  293.    * @param   handle        Management handle.
  294.    * @return                Latest error message
  295.    */
  296.   const char * ndb_mgm_get_latest_error_msg(const NdbMgmHandle handle);
  297.   /**
  298.    * Get latest error description associated with a handle
  299.    *
  300.    * The error description gives some additional information to 
  301.    * the error message.
  302.    *
  303.    * @param   handle        Management handle.
  304.    * @return                Latest error description
  305.    */
  306.   const char * ndb_mgm_get_latest_error_desc(const NdbMgmHandle handle);
  307. #ifndef DOXYGEN_SHOULD_SKIP_DEPRECATED
  308.   /**
  309.    * Get latest internal source code error line associated with a handle
  310.    *
  311.    * @param   handle        Management handle.
  312.    * @return                Latest internal source code line of latest error
  313.    * @deprecated 
  314.    */
  315.   int ndb_mgm_get_latest_error_line(const NdbMgmHandle handle);
  316. #endif
  317.   /**
  318.    * Set error stream
  319.    */
  320.   void ndb_mgm_set_error_stream(NdbMgmHandle, FILE *);
  321.   /** @} *********************************************************************/
  322.   /** 
  323.    * @name Functions: Create/Destroy Management Server Handles
  324.    * @{
  325.    */
  326.   /** 
  327.    * Create a handle to a management server
  328.    *
  329.    * @return                 A management handle<br>
  330.    *                         or NULL if no management handle could be created. 
  331.    */
  332.   NdbMgmHandle ndb_mgm_create_handle();
  333.   
  334.   /** 
  335.    * Set connecst string to management server
  336.    *
  337.    * @param   handle         Management handle
  338.    * @param   connect_string Connect string to the management server, 
  339.    *
  340.    * @return                -1 on error.
  341.    */
  342.   int ndb_mgm_set_connectstring(NdbMgmHandle handle,
  343. const char *connect_string);
  344.   int ndb_mgm_set_configuration_nodeid(NdbMgmHandle handle, int nodeid);
  345.   int ndb_mgm_get_configuration_nodeid(NdbMgmHandle handle);
  346.   int ndb_mgm_get_connected_port(NdbMgmHandle handle);
  347.   const char *ndb_mgm_get_connected_host(NdbMgmHandle handle);
  348.   const char *ndb_mgm_get_connectstring(NdbMgmHandle handle, char *buf, int buf_sz);
  349.   /**
  350.    * Destroy a management server handle
  351.    *
  352.    * @param   handle        Management handle
  353.    */
  354.   void ndb_mgm_destroy_handle(NdbMgmHandle * handle);
  355.   
  356.   /** @} *********************************************************************/
  357.   /** 
  358.    * @name Functions: Connect/Disconnect Management Server
  359.    * @{
  360.    */
  361.   /**
  362.    * Connect to a management server
  363.    *
  364.    * @param   handle        Management handle.
  365.    * @return                -1 on error.
  366.    */
  367.   int ndb_mgm_connect(NdbMgmHandle handle, int no_retries,
  368.       int retry_delay_in_seconds, int verbose);
  369.   
  370.   /**
  371.    * Disconnect from a management server
  372.    *
  373.    * @param  handle         Management handle.
  374.    * @return                -1 on error.
  375.    */
  376.   int ndb_mgm_disconnect(NdbMgmHandle handle);
  377.   
  378.   /** @} *********************************************************************/
  379.   /** 
  380.    * @name Functions: Convert between different data formats
  381.    * @{
  382.    */
  383.   /**
  384.    * Convert a string to a ndb_mgm_node_type
  385.    *
  386.    * @param   type          Node type as string.
  387.    * @return                NDB_MGM_NODE_TYPE_UNKNOWN if invalid string.
  388.    */
  389.   enum ndb_mgm_node_type ndb_mgm_match_node_type(const char * type);
  390.   /**
  391.    * Convert an ndb_mgm_node_type to a string
  392.    *
  393.    * @param   type          Node type.
  394.    * @return                NULL if invalid id.
  395.    */
  396.   const char * ndb_mgm_get_node_type_string(enum ndb_mgm_node_type type);
  397.   /**
  398.    * Convert an ndb_mgm_node_type to a alias string
  399.    *
  400.    * @param   type          Node type.
  401.    * @return                NULL if invalid id.
  402.    */
  403.   const char * ndb_mgm_get_node_type_alias_string(enum ndb_mgm_node_type type, const char **str);
  404.   /**
  405.    * Convert a string to a ndb_mgm_node_status
  406.    *
  407.    * @param   status        NDB node status string.
  408.    * @return                NDB_MGM_NODE_STATUS_UNKNOWN if invalid string.
  409.    */
  410.   enum ndb_mgm_node_status ndb_mgm_match_node_status(const char * status);
  411.   /**
  412.    * Convert an id to a string
  413.    *
  414.    * @param   status        NDB node status.
  415.    * @return                NULL if invalid id.
  416.    */
  417.   const char * ndb_mgm_get_node_status_string(enum ndb_mgm_node_status status);
  418.   ndb_mgm_event_category ndb_mgm_match_event_category(const char *);
  419.   const char * ndb_mgm_get_event_category_string(enum ndb_mgm_event_category);
  420.   /** @} *********************************************************************/
  421.   /** 
  422.    * @name Functions: State of cluster
  423.    * @{
  424.    */
  425.   /**
  426.    * Get status of the nodes in an NDB Cluster
  427.    *
  428.    * Note the caller must free the pointer returned.
  429.    *
  430.    * @param   handle        Management handle.
  431.    * @return                Cluster state (or NULL on error).
  432.    */
  433.   struct ndb_mgm_cluster_state * ndb_mgm_get_status(NdbMgmHandle handle);
  434.   /** @} *********************************************************************/
  435.   /** 
  436.    * @name Functions: Start/stop nodes 
  437.    * @{
  438.    */
  439.   /**
  440.    * Stop database nodes
  441.    *
  442.    * @param   handle        Management handle.
  443.    * @param   no_of_nodes   no of database nodes<br>
  444.    *                        0 - means all database nodes in cluster<br>
  445.    *                        n - Means stop n node(s) specified in the 
  446.    *                            array node_list
  447.    * @param   node_list     List of node ids of database nodes to be stopped
  448.    * @return                No of nodes stopped (or -1 on error)
  449.    *
  450.    * @note    The function is equivalent 
  451.    *          to ndb_mgm_stop2(handle, no_of_nodes, node_list, 0)
  452.    */
  453.   int ndb_mgm_stop(NdbMgmHandle handle, int no_of_nodes, 
  454.    const int * node_list);
  455.   /**
  456.    * Stop database nodes
  457.    *
  458.    * @param   handle        Management handle.
  459.    * @param   no_of_nodes   No of database nodes<br>
  460.    *                        0 - means all database nodes in cluster<br>
  461.    *                        n - Means stop n node(s) specified in 
  462.    *                            the array node_list
  463.    * @param   node_list     List of node ids of database nodes to be stopped
  464.    * @param   abort         Don't perform gracefull stop, 
  465.    *                        but rather stop immediatly
  466.    * @return                No of nodes stopped (or -1 on error).
  467.    */
  468.   int ndb_mgm_stop2(NdbMgmHandle handle, int no_of_nodes,
  469.     const int * node_list, int abort);
  470.   /**
  471.    * Restart database nodes
  472.    *
  473.    * @param   handle        Management handle.
  474.    * @param   no_of_nodes   No of database nodes<br>
  475.    *                        0 - means all database nodes in cluster<br>
  476.    *                        n - Means stop n node(s) specified in the 
  477.    *                            array node_list
  478.    * @param   node_list     List of node ids of database nodes to be stopped
  479.    * @return                No of nodes stopped (or -1 on error).
  480.    *
  481.    * @note    The function is equivalent to 
  482.    *          ndb_mgm_restart2(handle, no_of_nodes, node_list, 0, 0, 0);
  483.    */
  484.   int ndb_mgm_restart(NdbMgmHandle handle, int no_of_nodes, 
  485.       const int * node_list);
  486.   /**
  487.    * Restart database nodes
  488.    *
  489.    * @param   handle        Management handle.
  490.    * @param   no_of_nodes   No of database nodes<br>
  491.    *                        0 - means all database nodes in cluster<br>
  492.    *                        n - Means stop n node(s) specified in the 
  493.    *                            array node_list
  494.    * @param   node_list     List of node ids of database nodes to be stopped
  495.    * @param   initial       Remove filesystem from node(s) restarting
  496.    * @param   nostart       Don't actually start node(s) but leave them 
  497.    *                        waiting for start command
  498.    * @param   abort         Don't perform gracefull restart, 
  499.    *                        but rather restart immediatly
  500.    * @return                No of nodes stopped (or -1 on error).
  501.    */
  502.   int ndb_mgm_restart2(NdbMgmHandle handle, int no_of_nodes,
  503.        const int * node_list, int initial,
  504.        int nostart, int abort);
  505.        
  506.   /**
  507.    * Start database nodes
  508.    *
  509.    * @param   handle        Management handle.
  510.    * @param   no_of_nodes   No of database nodes<br>
  511.    *                        0 - means all database nodes in cluster<br>
  512.    *                        n - Means start n node(s) specified in 
  513.    *                            the array node_list
  514.    * @param   node_list     List of node ids of database nodes to be started
  515.    * @return                No of nodes started (or -1 on error).
  516.    *
  517.    * @note    The nodes to start must have been started with nostart(-n) 
  518.    *          argument.
  519.    *          This means that the database node binary is started and 
  520.    *          waiting for a START management command which will 
  521.    *          actually start the database node functionality
  522.    */
  523.   int ndb_mgm_start(NdbMgmHandle handle,
  524.     int no_of_nodes,
  525.     const int * node_list);
  526.   /** @} *********************************************************************/
  527.   /** 
  528.    * @name Functions: Logging and Statistics
  529.    * @{
  530.    */
  531.   /**
  532.    * Filter cluster log
  533.    *
  534.    * @param   handle        NDB management handle.
  535.    * @param   level         A cluster log level to filter.
  536.    * @param   enable        set 1=enable 0=disable
  537.    * @param   reply         Reply message.
  538.    * @return                -1 on error.
  539.    */
  540.   int ndb_mgm_filter_clusterlog(NdbMgmHandle handle,
  541. enum ndb_mgm_clusterlog_level level,
  542. int enable,
  543. struct ndb_mgm_reply* reply);
  544.   /**
  545.    * Get log filter
  546.    * 
  547.    * @param   handle        NDB management handle
  548.    * @return                A vector of seven elements, 
  549.    *                        where each element contains
  550.    *                        1 if a severity is enabled and 0 if not. 
  551.    *                        A severity is stored at position 
  552.    *                        ndb_mgm_clusterlog_level, 
  553.    *                        for example the "error" level is stored in position
  554.    *                        [NDB_MGM_CLUSTERLOG_ERROR-1].
  555.    *                        The first element in the vector signals 
  556.    *                        whether the clusterlog
  557.    *                        is disabled or enabled.
  558.    */
  559.   unsigned int *ndb_mgm_get_logfilter(NdbMgmHandle handle);
  560.   /**
  561.    * Set log category and levels for the cluster log
  562.    *
  563.    * @param   handle        NDB management handle.
  564.    * @param   nodeId        Node id.
  565.    * @param   category      Event category.
  566.    * @param   level         Log level (0-15).
  567.    * @param   reply         Reply message.
  568.    * @return                -1 on error.
  569.    */
  570.   int ndb_mgm_set_loglevel_clusterlog(NdbMgmHandle handle,
  571.       int nodeId,
  572.       enum ndb_mgm_event_category category,
  573.       int level,
  574.       struct ndb_mgm_reply* reply);
  575.   ndb_mgm_clusterlog_level
  576.   ndb_mgm_match_clusterlog_level(const char * name);
  577.   const char * 
  578.   ndb_mgm_get_clusterlog_level_string(enum ndb_mgm_clusterlog_level level);
  579.   /**
  580.    * Set log category and levels for the Node
  581.    *
  582.    * @param   handle        NDB management handle.
  583.    * @param   nodeId        Node id.
  584.    * @param   category      Event category.
  585.    * @param   level         Log level (0-15).
  586.    * @param   reply         Reply message.
  587.    * @return                -1 on error.
  588.    */
  589.   int ndb_mgm_set_loglevel_node(NdbMgmHandle handle,
  590. int nodeId,
  591. enum ndb_mgm_event_category category,
  592. int level,
  593. struct ndb_mgm_reply* reply);
  594.   /**
  595.    * Returns the port number where statistics information is sent
  596.    *
  597.    * @param   handle        NDB management handle.
  598.    * @param   reply         Reply message.
  599.    * @return                -1 on error.
  600.    */
  601.   int ndb_mgm_get_stat_port(NdbMgmHandle handle,
  602.     struct ndb_mgm_reply* reply);
  603.   /** @} *********************************************************************/
  604.   /** 
  605.    * @name Functions: Backup
  606.    * @{
  607.    */
  608.   /**
  609.    * Start backup
  610.    *
  611.    * @param   handle        NDB management handle.
  612.    * @param   wait_completed 0=don't wait for confirmation
  613.                              1=wait for backup started
  614.                              2=wait for backup completed
  615.    * @param   backup_id     Backup id is returned from function.
  616.    * @param   reply         Reply message.
  617.    * @return                -1 on error.
  618.    */
  619.   int ndb_mgm_start_backup(NdbMgmHandle handle, int wait_completed,
  620.    unsigned int* backup_id,
  621.    struct ndb_mgm_reply* reply);
  622.   /**
  623.    * Abort backup
  624.    *
  625.    * @param   handle        NDB management handle.
  626.    * @param   backup_id     Backup Id.
  627.    * @param   reply         Reply message.
  628.    * @return                -1 on error.
  629.    */
  630.   int ndb_mgm_abort_backup(NdbMgmHandle handle, unsigned int backup_id,
  631.    struct ndb_mgm_reply* reply);
  632.   /** @} *********************************************************************/
  633.   /** 
  634.    * @name Functions: Single User Mode
  635.    * @{
  636.    */
  637.   /**
  638.    * Enter Single user mode 
  639.    *
  640.    * @param   handle        NDB management handle.
  641.    * @param   nodeId        Node Id of the single user node
  642.    * @param   reply         Reply message.
  643.    * @return                -1 on error.
  644.    */
  645.   int ndb_mgm_enter_single_user(NdbMgmHandle handle, unsigned int nodeId,
  646. struct ndb_mgm_reply* reply);
  647.   
  648.   /**
  649.    * Exit Single user mode 
  650.    *
  651.    * @param   handle        NDB management handle.
  652.    * @param   nodeId        Node Id of the single user node
  653.    * @param   reply         Reply message.
  654.    * @return                -1 on error.
  655.    */
  656.   int ndb_mgm_exit_single_user(NdbMgmHandle handle, 
  657.        struct ndb_mgm_reply* reply);
  658.   
  659.   /**
  660.    * Listen event
  661.    *
  662.    * @param filter pairs of { level, category } that will be
  663.    *        pushed to fd, level=0 ends lists
  664.    * @return fd which events will be pushed to
  665.    */
  666.   int ndb_mgm_listen_event(NdbMgmHandle handle, int filter[]);
  667.   
  668.   /**
  669.    * Get configuration
  670.    * @param   handle     NDB management handle.
  671.    * @param   version    Version of configuration, 0 means latest
  672.    *                     @see MAKE_VERSION
  673.    * @Note the caller must call ndb_mgm_detroy_configuration
  674.    */
  675.   struct ndb_mgm_configuration * ndb_mgm_get_configuration(NdbMgmHandle handle,
  676.    unsigned version);
  677.   void ndb_mgm_destroy_configuration(struct ndb_mgm_configuration *);
  678.   int ndb_mgm_alloc_nodeid(NdbMgmHandle handle,
  679.    unsigned version, int nodetype);
  680.   /**
  681.    * Config iterator
  682.    */
  683.   typedef struct ndb_mgm_configuration_iterator ndb_mgm_configuration_iterator;
  684.   ndb_mgm_configuration_iterator* ndb_mgm_create_configuration_iterator
  685.   (struct ndb_mgm_configuration *, unsigned type_of_section);
  686.   void ndb_mgm_destroy_iterator(ndb_mgm_configuration_iterator*);
  687.   
  688.   int ndb_mgm_first(ndb_mgm_configuration_iterator*);
  689.   int ndb_mgm_next(ndb_mgm_configuration_iterator*);
  690.   int ndb_mgm_valid(const ndb_mgm_configuration_iterator*);
  691.   int ndb_mgm_find(ndb_mgm_configuration_iterator*, 
  692.    int param, unsigned value);
  693.   
  694.   int ndb_mgm_get_int_parameter(const ndb_mgm_configuration_iterator*, 
  695. int param, unsigned * value);
  696.   int ndb_mgm_get_int64_parameter(const ndb_mgm_configuration_iterator*,
  697.   int param, Uint64 * value);
  698.   int ndb_mgm_get_string_parameter(const ndb_mgm_configuration_iterator*,
  699.    int param, const char  ** value);
  700.   int ndb_mgm_purge_stale_sessions(NdbMgmHandle handle, char **);
  701.   int ndb_mgm_check_connection(NdbMgmHandle handle);
  702. #ifdef __cplusplus
  703. }
  704. #endif
  705. /** @} */
  706. #endif