root/include/crm/cib/cib_types.h

/* [previous][next][first][last][top][bottom][index][help] */

INCLUDED FROM

   1 /*
   2  * Copyright 2004-2023 the Pacemaker project contributors
   3  *
   4  * The version control history for this file may have further details.
   5  *
   6  * This source code is licensed under the GNU Lesser General Public License
   7  * version 2.1 or later (LGPLv2.1+) WITHOUT ANY WARRANTY.
   8  */
   9 
  10 #ifndef PCMK__CRM_CIB_CIB_TYPES__H
  11 #  define PCMK__CRM_CIB_CIB_TYPES__H
  12 
  13 #  include <glib.h>             // gboolean, GList
  14 #  include <libxml/tree.h>      // xmlNode
  15 #  include <crm/common/ipc.h>
  16 #  include <crm/common/xml.h>
  17 
  18 #ifdef __cplusplus
  19 extern "C" {
  20 #endif
  21 
  22 /**
  23  * \file
  24  * \brief Data types for Cluster Information Base access
  25  * \ingroup cib
  26  */
  27 
  28 enum cib_variant {
  29     cib_undefined = 0,
  30     cib_native    = 1,
  31     cib_file      = 2,
  32     cib_remote    = 3,
  33 
  34 #if !defined(PCMK_ALLOW_DEPRECATED) || (PCMK_ALLOW_DEPRECATED == 1)
  35     //! \deprecated This value will be removed in a future release
  36     cib_database  = 4,
  37 #endif // !defined(PCMK_ALLOW_DEPRECATED) || (PCMK_ALLOW_DEPRECATED == 1)
  38 };
  39 
  40 enum cib_state {
  41     cib_connected_command,
  42     cib_connected_query,
  43     cib_disconnected
  44 };
  45 
  46 enum cib_conn_type {
  47     cib_command,
  48     cib_query,
  49     cib_no_connection,
  50     cib_command_nonblocking,
  51 };
  52 
  53 enum cib_call_options {
  54     cib_none            = 0,
  55     cib_verbose         = (1 << 0),  //!< Prefer stderr to logs
  56     cib_xpath           = (1 << 1),
  57     cib_multiple        = (1 << 2),
  58     cib_can_create      = (1 << 3),
  59     cib_discard_reply   = (1 << 4),
  60     cib_no_children     = (1 << 5),
  61     cib_xpath_address   = (1 << 6),
  62     cib_mixed_update    = (1 << 7),
  63     cib_scope_local     = (1 << 8),
  64     cib_dryrun          = (1 << 9),
  65     cib_sync_call       = (1 << 12),
  66     cib_no_mtime        = (1 << 13),
  67     cib_zero_copy       = (1 << 14),
  68     cib_inhibit_notify  = (1 << 16),
  69 
  70 #if !defined(PCMK_ALLOW_DEPRECATED) || (PCMK_ALLOW_DEPRECATED == 1)
  71     //! \deprecated This value will be removed in a future release
  72     cib_quorum_override = (1 << 20),
  73 #endif // !defined(PCMK_ALLOW_DEPRECATED) || (PCMK_ALLOW_DEPRECATED == 1)
  74 
  75     //! \deprecated This value will be removed in a future release
  76     cib_inhibit_bcast   = (1 << 24),
  77 
  78     cib_force_diff      = (1 << 28),
  79 };
  80 
  81 typedef struct cib_s cib_t;
  82 
  83 typedef struct cib_api_operations_s {
  84     int (*signon) (cib_t *cib, const char *name, enum cib_conn_type type);
  85     int (*signon_raw) (cib_t *cib, const char *name, enum cib_conn_type type,
  86                        int *event_fd);
  87     int (*signoff) (cib_t *cib);
  88     int (*free) (cib_t *cib);
  89     int (*set_op_callback) (cib_t *cib, void (*callback) (const xmlNode *msg,
  90                                                           int callid, int rc,
  91                                                           xmlNode *output));
  92     int (*add_notify_callback) (cib_t *cib, const char *event,
  93                                 void (*callback) (const char *event,
  94                                                   xmlNode *msg));
  95     int (*del_notify_callback) (cib_t *cib, const char *event,
  96                                 void (*callback) (const char *event,
  97                                                   xmlNode *msg));
  98     int (*set_connection_dnotify) (cib_t *cib,
  99                                    void (*dnotify) (gpointer user_data));
 100     int (*inputfd) (cib_t *cib);
 101     int (*noop) (cib_t *cib, int call_options);
 102     int (*ping) (cib_t *cib, xmlNode **output_data, int call_options);
 103     int (*query) (cib_t *cib, const char *section, xmlNode **output_data,
 104                   int call_options);
 105     int (*query_from) (cib_t *cib, const char *host, const char *section,
 106                        xmlNode **output_data, int call_options);
 107 
 108     //! \deprecated This method will be removed and should not be used
 109     int (*is_master) (cib_t *cib);
 110 
 111     //! \deprecated Use the set_primary() method instead
 112     int (*set_master) (cib_t *cib, int call_options);
 113 
 114     //! \deprecated Use the set_secondary() method instead
 115     int (*set_slave) (cib_t *cib, int call_options);
 116 
 117     //! \deprecated This method will be removed and should not be used
 118     int (*set_slave_all) (cib_t *cib, int call_options);
 119 
 120     int (*sync) (cib_t *cib, const char *section, int call_options);
 121     int (*sync_from) (cib_t *cib, const char *host, const char *section,
 122                       int call_options);
 123     int (*upgrade) (cib_t *cib, int call_options);
 124     int (*bump_epoch) (cib_t *cib, int call_options);
 125     int (*create) (cib_t *cib, const char *section, xmlNode *data,
 126                    int call_options);
 127     int (*modify) (cib_t *cib, const char *section, xmlNode *data,
 128                    int call_options);
 129 
 130     //! \deprecated Use the \p modify() method instead
 131     int (*update) (cib_t *cib, const char *section, xmlNode *data,
 132                    int call_options);
 133 
 134     int (*replace) (cib_t *cib, const char *section, xmlNode *data,
 135                     int call_options);
 136     int (*remove) (cib_t *cib, const char *section, xmlNode *data,
 137                    int call_options);
 138     int (*erase) (cib_t *cib, xmlNode **output_data, int call_options);
 139 
 140     //! \deprecated This method does nothing and should not be called
 141     int (*delete_absolute) (cib_t *cib, const char *section, xmlNode *data,
 142                             int call_options);
 143 
 144     int (*quit) (cib_t *cib, int call_options);
 145     int (*register_notification) (cib_t *cib, const char *callback,
 146                                   int enabled);
 147     gboolean (*register_callback) (cib_t *cib, int call_id, int timeout,
 148                                    gboolean only_success, void *user_data,
 149                                    const char *callback_name,
 150                                    void (*callback) (xmlNode*, int, int,
 151                                                      xmlNode*, void *));
 152     gboolean (*register_callback_full)(cib_t *cib, int call_id, int timeout,
 153                                        gboolean only_success, void *user_data,
 154                                        const char *callback_name,
 155                                        void (*callback)(xmlNode *, int, int,
 156                                                         xmlNode *, void *),
 157                                        void (*free_func)(void *));
 158 
 159     /*!
 160      * \brief Set the local CIB manager as the cluster's primary instance
 161      *
 162      * \param[in,out] cib           CIB connection
 163      * \param[in]     call_options  Group of enum cib_call_options flags
 164      *
 165      * \return Legacy Pacemaker return code (in particular, pcmk_ok on success)
 166      */
 167     int (*set_primary)(cib_t *cib, int call_options);
 168 
 169     /*!
 170      * \brief Set the local CIB manager as a secondary instance
 171      *
 172      * \param[in,out] cib           CIB connection
 173      * \param[in]     call_options  Group of enum cib_call_options flags
 174      *
 175      * \return Legacy Pacemaker return code (in particular, pcmk_ok on success)
 176      */
 177     int (*set_secondary)(cib_t *cib, int call_options);
 178 
 179     /*!
 180      * \brief Get the given CIB connection's unique client identifier(s)
 181      *
 182      * These can be used to check whether this client requested the action that
 183      * triggered a CIB notification.
 184      *
 185      * \param[in]  cib       CIB connection
 186      * \param[out] async_id  If not \p NULL, where to store asynchronous client
 187      *                       ID
 188      * \param[out] sync_id   If not \p NULL, where to store synchronous client
 189      *                       ID
 190      *
 191      * \return Legacy Pacemaker return code
 192      *
 193      * \note The client IDs are assigned by \p pacemaker-based when the client
 194      *       connects. \p cib_t variants that don't connect to
 195      *       \p pacemaker-based may never be assigned a client ID.
 196      * \note Some variants may have only one client for both asynchronous and
 197      *       synchronous requests.
 198      */
 199     int (*client_id)(const cib_t *cib, const char **async_id,
 200                      const char **sync_id);
 201 } cib_api_operations_t;
 202 
 203 struct cib_s {
 204     enum cib_state state;
 205     enum cib_conn_type type;
 206     enum cib_variant variant;
 207 
 208     int call_id;
 209     int call_timeout;
 210     void *variant_opaque;
 211     void *delegate_fn;
 212 
 213     GList *notify_list;
 214     void (*op_callback) (const xmlNode *msg, int call_id, int rc,
 215                          xmlNode *output);
 216     cib_api_operations_t *cmds;
 217 };
 218 
 219 #ifdef __cplusplus
 220 }
 221 #endif
 222 
 223 #endif // PCMK__CRM_CIB_CIB_TYPES__H
/* [previous][next][first][last][top][bottom][index][help] */