mgmapi.h

/*
   Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; version 2 of the License.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA
*/

#ifndef MGMAPI_H
#define MGMAPI_H

#include "mgmapi_config_parameters.h"
#include "ndb_logevent.h"
#include "mgmapi_error.h"

#define MGM_LOGLEVELS CFG_MAX_LOGLEVEL - CFG_MIN_LOGLEVEL + 1
#define NDB_MGM_MAX_LOGLEVEL 15

/*
 * @page ndb_logevent.h ndb_logevent.h
 * @include ndb_logevent.h
 */

#include <stdio.h>
#include <ndb_types.h>
#include "ndb_logevent.h"
#include "mgmapi_config_parameters.h"

#ifdef __cplusplus
extern "C" {
#endif

  typedef struct ndb_mgm_handle * NdbMgmHandle;

  enum ndb_mgm_node_type {
    NDB_MGM_NODE_TYPE_UNKNOWN = -1  
    ,NDB_MGM_NODE_TYPE_API    
#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
    = NODE_TYPE_API
#endif
    ,NDB_MGM_NODE_TYPE_NDB    
#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
    = NODE_TYPE_DB
#endif
    ,NDB_MGM_NODE_TYPE_MGM    
#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
    = NODE_TYPE_MGM
#endif
#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
    ,NDB_MGM_NODE_TYPE_MIN     = 0          
    ,NDB_MGM_NODE_TYPE_MAX     = 3          
#endif
  };

  enum ndb_mgm_node_status {
    NDB_MGM_NODE_STATUS_UNKNOWN       = 0,
    NDB_MGM_NODE_STATUS_NO_CONTACT    = 1,
    NDB_MGM_NODE_STATUS_NOT_STARTED   = 2,
    NDB_MGM_NODE_STATUS_STARTING      = 3,
    NDB_MGM_NODE_STATUS_STARTED       = 4,
    NDB_MGM_NODE_STATUS_SHUTTING_DOWN = 5,
    NDB_MGM_NODE_STATUS_RESTARTING    = 6,
    NDB_MGM_NODE_STATUS_SINGLEUSER    = 7,
    NDB_MGM_NODE_STATUS_RESUME        = 8,
    NDB_MGM_NODE_STATUS_CONNECTED     = 9,
#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL

    NDB_MGM_NODE_STATUS_MIN           = 0,
    NDB_MGM_NODE_STATUS_MAX           = 9
#endif
  };

  struct ndb_mgm_node_state {
    int node_id;
    enum ndb_mgm_node_type   node_type;
    enum ndb_mgm_node_status node_status;
    int start_phase;
    int dynamic_id;
    int node_group;
    int version;
    int connect_count;
    char connect_address[
#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
                         sizeof("000.000.000.000")+1
#endif
    ];

    int mysql_version;
  };
  
  struct ndb_mgm_cluster_state {
    int no_of_nodes;
    struct ndb_mgm_node_state node_states[
#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
                                          1
#endif
    ];
  };

  struct ndb_mgm_reply {
    int return_code;
    char message[256];
  };

#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL

  enum ndb_mgm_info {
    NDB_MGM_INFO_CLUSTER,
    NDB_MGM_INFO_CLUSTERLOG
  };

  enum ndb_mgm_signal_log_mode {
    NDB_MGM_SIGNAL_LOG_MODE_IN,
    NDB_MGM_SIGNAL_LOG_MODE_OUT,
    NDB_MGM_SIGNAL_LOG_MODE_INOUT,
    NDB_MGM_SIGNAL_LOG_MODE_OFF
  };
#endif

  struct ndb_mgm_severity {
    enum ndb_mgm_event_severity category;
    unsigned int value;
  };

  struct ndb_mgm_loglevel {
    enum ndb_mgm_event_category category;
    unsigned int value;
  };


  /***************************************************************************/
  int ndb_mgm_get_latest_error(const NdbMgmHandle handle);

  const char * ndb_mgm_get_latest_error_msg(const NdbMgmHandle handle);

  const char * ndb_mgm_get_latest_error_desc(const NdbMgmHandle handle);

#ifndef DOXYGEN_SHOULD_SKIP_DEPRECATED

  int ndb_mgm_get_latest_error_line(const NdbMgmHandle handle);
#endif

  void ndb_mgm_set_error_stream(NdbMgmHandle, FILE *);


  NdbMgmHandle ndb_mgm_create_handle();

  void ndb_mgm_destroy_handle(NdbMgmHandle * handle);

  void ndb_mgm_set_name(NdbMgmHandle handle, const char *name);

  int ndb_mgm_set_ignore_sigpipe(NdbMgmHandle handle, int val);

  int ndb_mgm_set_connectstring(NdbMgmHandle handle,
                                const char *connect_string);

  int ndb_mgm_number_of_mgmd_in_connect_string(NdbMgmHandle handle);

  int ndb_mgm_set_configuration_nodeid(NdbMgmHandle handle, int nodeid);

  int ndb_mgm_set_bindaddress(NdbMgmHandle, const char * arg);

  const char *ndb_mgm_get_connectstring(NdbMgmHandle handle, char *buf, int buf_sz);

  int ndb_mgm_set_connect_timeout(NdbMgmHandle handle, unsigned int seconds);

  int ndb_mgm_set_timeout(NdbMgmHandle handle, unsigned int timeout_ms);

  int ndb_mgm_connect(NdbMgmHandle handle, int no_retries,
                      int retry_delay_in_seconds, int verbose);
  int ndb_mgm_is_connected(NdbMgmHandle handle);

  int ndb_mgm_disconnect(NdbMgmHandle handle);

  int ndb_mgm_get_configuration_nodeid(NdbMgmHandle handle);

  int ndb_mgm_get_connected_port(NdbMgmHandle handle);

  const char *ndb_mgm_get_connected_host(NdbMgmHandle handle);

  const char *ndb_mgm_get_connected_bind_address(NdbMgmHandle handle);

  int ndb_mgm_get_version(NdbMgmHandle handle,
                          int *major, int *minor, int* build,
                          int len, char* str);

#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL

  enum ndb_mgm_node_type ndb_mgm_match_node_type(const char * type);

  const char * ndb_mgm_get_node_type_string(enum ndb_mgm_node_type type);

  const char * ndb_mgm_get_node_type_alias_string(enum ndb_mgm_node_type type,
                                                  const char **str);

  enum ndb_mgm_node_status ndb_mgm_match_node_status(const char * status);

  const char * ndb_mgm_get_node_status_string(enum ndb_mgm_node_status status);

  const char * ndb_mgm_get_event_severity_string(enum ndb_mgm_event_severity);
  enum ndb_mgm_event_category ndb_mgm_match_event_category(const char *);
  const char * ndb_mgm_get_event_category_string(enum ndb_mgm_event_category);
#endif

  struct ndb_mgm_cluster_state * ndb_mgm_get_status(NdbMgmHandle handle);


  struct ndb_mgm_cluster_state * 
  ndb_mgm_get_status2(NdbMgmHandle handle,
                      const enum ndb_mgm_node_type types[]);
                      


  int ndb_mgm_dump_state(NdbMgmHandle handle,
                         int nodeId,
                         const int * args,
                         int num_args,
                         struct ndb_mgm_reply* reply);

  struct ndb_mgm_configuration *
  ndb_mgm_get_configuration_from_node(NdbMgmHandle handle,
                                      int nodeid);


  int ndb_mgm_stop(NdbMgmHandle handle, int no_of_nodes,
                   const int * node_list);

  int ndb_mgm_stop2(NdbMgmHandle handle, int no_of_nodes,
                    const int * node_list, int abort);

  int ndb_mgm_stop3(NdbMgmHandle handle, int no_of_nodes,
                    const int * node_list, int abort, int *disconnect);

   int ndb_mgm_stop4(NdbMgmHandle handle, int no_of_nodes,
                    const int * node_list, int abort, int force,
                    int *disconnect);

  int ndb_mgm_restart(NdbMgmHandle handle, int no_of_nodes,
                      const int * node_list);

  int ndb_mgm_restart2(NdbMgmHandle handle, int no_of_nodes,
                       const int * node_list, int initial,
                       int nostart, int abort);

  int ndb_mgm_restart3(NdbMgmHandle handle, int no_of_nodes,
                       const int * node_list, int initial,
                       int nostart, int abort, int *disconnect);

  int ndb_mgm_restart4(NdbMgmHandle handle, int no_of_nodes,
                       const int * node_list, int initial,
                       int nostart, int abort, int force, int *disconnect);

  int ndb_mgm_start(NdbMgmHandle handle,
                    int no_of_nodes,
                    const int * node_list);

  int ndb_mgm_set_clusterlog_severity_filter(NdbMgmHandle handle,
                                             enum ndb_mgm_event_severity severity,
                                             int enable,
                                             struct ndb_mgm_reply* reply);
  int ndb_mgm_get_clusterlog_severity_filter(NdbMgmHandle handle,
                                             struct ndb_mgm_severity* severity,
                                             unsigned int severity_size);

#ifndef DOXYGEN_SHOULD_SKIP_DEPRECATED

  const unsigned int *ndb_mgm_get_clusterlog_severity_filter_old(NdbMgmHandle handle);
#endif

  int ndb_mgm_set_clusterlog_loglevel(NdbMgmHandle handle,
                                      int nodeId,
                                      enum ndb_mgm_event_category category,
                                      int level,
                                      struct ndb_mgm_reply* reply);
  
  int ndb_mgm_get_clusterlog_loglevel(NdbMgmHandle handle,
                                      struct ndb_mgm_loglevel* loglevel,
                                      unsigned int loglevel_size);

#ifndef DOXYGEN_SHOULD_SKIP_DEPRECATED

  const unsigned int *ndb_mgm_get_clusterlog_loglevel_old(NdbMgmHandle handle);
#endif


#ifdef NDB_WIN
  SOCKET ndb_mgm_listen_event(NdbMgmHandle handle, const int filter[]);
#else
  int ndb_mgm_listen_event(NdbMgmHandle handle, const int filter[]);
#endif

#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL

  int ndb_mgm_set_loglevel_node(NdbMgmHandle handle,
                                int nodeId,
                                enum ndb_mgm_event_category category,
                                int level,
                                struct ndb_mgm_reply* reply);
#endif

  typedef struct ndb_logevent_handle * NdbLogEventHandle;

  NdbLogEventHandle ndb_mgm_create_logevent_handle(NdbMgmHandle,
                                                   const int filter[]);
  void ndb_mgm_destroy_logevent_handle(NdbLogEventHandle*);

#ifdef NDB_WIN
  SOCKET ndb_logevent_get_fd(const NdbLogEventHandle);
#else
  int ndb_logevent_get_fd(const NdbLogEventHandle);
#endif

  int ndb_logevent_get_next(const NdbLogEventHandle,
                            struct ndb_logevent *dst,
                            unsigned timeout_in_milliseconds);

  int ndb_logevent_get_latest_error(const NdbLogEventHandle);

  const char *ndb_logevent_get_latest_error_msg(const NdbLogEventHandle);


  int ndb_mgm_start_backup(NdbMgmHandle handle, int wait_completed,
                           unsigned int* backup_id,
                           struct ndb_mgm_reply* reply);

  int ndb_mgm_start_backup2(NdbMgmHandle handle, int wait_completed,
                           unsigned int* backup_id,
                           struct ndb_mgm_reply* reply,
                           unsigned int input_backupId);

  int ndb_mgm_start_backup3(NdbMgmHandle handle, int wait_completed,
                           unsigned int* backup_id,
                           struct ndb_mgm_reply* reply,
                           unsigned int input_backupId,
                           unsigned int backuppoint);

  int ndb_mgm_abort_backup(NdbMgmHandle handle, unsigned int backup_id,
                           struct ndb_mgm_reply* reply);


  int ndb_mgm_enter_single_user(NdbMgmHandle handle, unsigned int nodeId,
                                struct ndb_mgm_reply* reply);

  int ndb_mgm_exit_single_user(NdbMgmHandle handle,
                               struct ndb_mgm_reply* reply);

#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL

  struct ndb_mgm_configuration * ndb_mgm_get_configuration(NdbMgmHandle handle,
                                                           unsigned version);
  void ndb_mgm_destroy_configuration(struct ndb_mgm_configuration *);

  int ndb_mgm_alloc_nodeid(NdbMgmHandle handle,
                           unsigned version, int nodetype, int log_event);

  int ndb_mgm_end_session(NdbMgmHandle handle);

#ifdef NDB_WIN
  SOCKET ndb_mgm_get_fd(NdbMgmHandle handle);
#else
  int ndb_mgm_get_fd(NdbMgmHandle handle);
#endif

  Uint32 ndb_mgm_get_mgmd_nodeid(NdbMgmHandle handle);

  typedef struct ndb_mgm_configuration_iterator ndb_mgm_configuration_iterator;

  ndb_mgm_configuration_iterator* ndb_mgm_create_configuration_iterator
  (struct ndb_mgm_configuration *, unsigned type_of_section);
  void ndb_mgm_destroy_iterator(ndb_mgm_configuration_iterator*);

  int ndb_mgm_first(ndb_mgm_configuration_iterator*);
  int ndb_mgm_next(ndb_mgm_configuration_iterator*);
  int ndb_mgm_valid(const ndb_mgm_configuration_iterator*);
  int ndb_mgm_find(ndb_mgm_configuration_iterator*,
                   int param, unsigned value);

  int ndb_mgm_get_int_parameter(const ndb_mgm_configuration_iterator*,
                                int param, unsigned * value);
  int ndb_mgm_get_int64_parameter(const ndb_mgm_configuration_iterator*,
                                  int param, Uint64 * value);
  int ndb_mgm_get_string_parameter(const ndb_mgm_configuration_iterator*,
                                   int param, const char  ** value);
  int ndb_mgm_purge_stale_sessions(NdbMgmHandle handle, char **);
  int ndb_mgm_check_connection(NdbMgmHandle handle);

  int ndb_mgm_report_event(NdbMgmHandle handle, Uint32 *data, Uint32 length);

  struct ndb_mgm_param_info
  {
    Uint32 m_id;
    const char * m_name;
  };
  int ndb_mgm_get_db_parameter_info(Uint32 paramId, struct ndb_mgm_param_info * info, 
             size_t * size);
#endif

  int ndb_mgm_create_nodegroup(NdbMgmHandle handle,
                               int * nodes,
                               int * ng,
                               struct ndb_mgm_reply* mgmreply);

  int ndb_mgm_drop_nodegroup(NdbMgmHandle handle,
                             int ng,
                             struct ndb_mgm_reply* mgmreply);

#ifndef DOXYGEN_SHOULD_SKIP_DEPRECATED
  enum ndb_mgm_clusterlog_level {
     NDB_MGM_ILLEGAL_CLUSTERLOG_LEVEL = -1,
     NDB_MGM_CLUSTERLOG_ON    = 0,
     NDB_MGM_CLUSTERLOG_DEBUG = 1,
     NDB_MGM_CLUSTERLOG_INFO = 2,
     NDB_MGM_CLUSTERLOG_WARNING = 3,
     NDB_MGM_CLUSTERLOG_ERROR = 4,
     NDB_MGM_CLUSTERLOG_CRITICAL = 5,
     NDB_MGM_CLUSTERLOG_ALERT = 6,
     NDB_MGM_CLUSTERLOG_ALL = 7
  };
  static inline
  int ndb_mgm_filter_clusterlog(NdbMgmHandle h,
                                enum ndb_mgm_clusterlog_level s,
                                int e, struct ndb_mgm_reply* r)
  { return ndb_mgm_set_clusterlog_severity_filter(h,(enum ndb_mgm_event_severity)s,
                                                  e,r); }
  static inline
  const unsigned int * ndb_mgm_get_logfilter(NdbMgmHandle h)
  { return ndb_mgm_get_clusterlog_severity_filter_old(h); }

  static inline
  int ndb_mgm_set_loglevel_clusterlog(NdbMgmHandle h, int n,
                                      enum ndb_mgm_event_category c,
                                      int l, struct ndb_mgm_reply* r)
  { return ndb_mgm_set_clusterlog_loglevel(h,n,c,l,r); }

  static inline
  const unsigned int * ndb_mgm_get_loglevel_clusterlog(NdbMgmHandle h)
  { return ndb_mgm_get_clusterlog_loglevel_old(h); }

#endif

  struct ndb_mgm_events {
    int no_of_events;
    struct ndb_logevent events [
#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
                    1
#endif
    ];
  };

  struct ndb_mgm_events*
  ndb_mgm_dump_events(NdbMgmHandle handle, enum Ndb_logevent_type type,
                      int no_of_nodes, const int * node_list);

#ifdef __cplusplus
}
#endif

#endif