cib_types.h

Go to the documentation of this file.

/*
 * Copyright 2004-2023 the Pacemaker project contributors
 *
 * The version control history for this file may have further details.
 *
 * This source code is licensed under the GNU Lesser General Public License
 * version 2.1 or later (LGPLv2.1+) WITHOUT ANY WARRANTY.
 */
 
#ifndef PCMK__CRM_CIB_CIB_TYPES__H
#  define PCMK__CRM_CIB_CIB_TYPES__H
 
#  include <glib.h>             // gboolean, GList
#  include <libxml/tree.h>      // xmlNode
#  include <crm/common/ipc.h>
#  include <crm/common/xml.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
enum cib_variant {
    cib_undefined = 0,
    cib_native    = 1,
    cib_file      = 2,
    cib_remote    = 3,
 
#if !defined(PCMK_ALLOW_DEPRECATED) || (PCMK_ALLOW_DEPRECATED == 1)
    cib_database  = 4,
#endif // !defined(PCMK_ALLOW_DEPRECATED) || (PCMK_ALLOW_DEPRECATED == 1)
};
 
enum cib_state {
    cib_connected_command,
    cib_connected_query,
    cib_disconnected
};
 
enum cib_conn_type {
    cib_command,
    cib_query,
    cib_no_connection,
    cib_command_nonblocking,
};
 
enum cib_call_options {
    cib_none            = 0,
    cib_verbose         = (1 << 0),  
    cib_xpath           = (1 << 1),
    cib_multiple        = (1 << 2),
    cib_can_create      = (1 << 3),
    cib_discard_reply   = (1 << 4),
    cib_no_children     = (1 << 5),
    cib_xpath_address   = (1 << 6),
 
    cib_mixed_update    = (1 << 7),
 
    /* @COMPAT: cib_scope_local is processed only in the legacy function
     * parse_local_options_v1().
     *
     * If (host == NULL):
     * * In legacy mode, the CIB manager forwards a request to the primary
     *   instance unless cib_scope_local is set or the local node is primary.
     * * Outside of legacy mode:
     *   * If a request modifies the CIB, the CIB manager forwards it to all
     *     nodes.
     *   * Otherwise, the CIB manager processes the request locally.
     *
     * There is no current use case for this implementing this flag in
     * non-legacy mode.
     */
 
    cib_scope_local     = (1 << 8),
 
    cib_dryrun          = (1 << 9),
 
    cib_transaction     = (1 << 10),
 
    cib_sync_call       = (1 << 12),
    cib_no_mtime        = (1 << 13),
 
#if !defined(PCMK_ALLOW_DEPRECATED) || (PCMK_ALLOW_DEPRECATED == 1)
    cib_zero_copy       = (1 << 14),
#endif // !defined(PCMK_ALLOW_DEPRECATED) || (PCMK_ALLOW_DEPRECATED == 1)
 
    cib_inhibit_notify  = (1 << 16),
 
#if !defined(PCMK_ALLOW_DEPRECATED) || (PCMK_ALLOW_DEPRECATED == 1)
    cib_quorum_override = (1 << 20),
#endif // !defined(PCMK_ALLOW_DEPRECATED) || (PCMK_ALLOW_DEPRECATED == 1)
 
    cib_inhibit_bcast   = (1 << 24),
 
    cib_force_diff      = (1 << 28),
};
 
typedef struct cib_s cib_t;
 
typedef struct cib_api_operations_s {
    int (*signon) (cib_t *cib, const char *name, enum cib_conn_type type);
 
    int (*signon_raw) (cib_t *cib, const char *name, enum cib_conn_type type,
                       int *event_fd);
 
    int (*signoff) (cib_t *cib);
    int (*free) (cib_t *cib);
 
    int (*set_op_callback) (cib_t *cib, void (*callback) (const xmlNode *msg,
                                                          int callid, int rc,
                                                          xmlNode *output));
 
    int (*add_notify_callback) (cib_t *cib, const char *event,
                                void (*callback) (const char *event,
                                                  xmlNode *msg));
    int (*del_notify_callback) (cib_t *cib, const char *event,
                                void (*callback) (const char *event,
                                                  xmlNode *msg));
    int (*set_connection_dnotify) (cib_t *cib,
                                   void (*dnotify) (gpointer user_data));
 
    int (*inputfd) (cib_t *cib);
 
    int (*noop) (cib_t *cib, int call_options);
 
    int (*ping) (cib_t *cib, xmlNode **output_data, int call_options);
    int (*query) (cib_t *cib, const char *section, xmlNode **output_data,
                  int call_options);
    int (*query_from) (cib_t *cib, const char *host, const char *section,
                       xmlNode **output_data, int call_options);
 
    int (*is_master) (cib_t *cib);
 
    int (*set_master) (cib_t *cib, int call_options);
 
    int (*set_slave) (cib_t *cib, int call_options);
 
    int (*set_slave_all) (cib_t *cib, int call_options);
 
    int (*sync) (cib_t *cib, const char *section, int call_options);
    int (*sync_from) (cib_t *cib, const char *host, const char *section,
                      int call_options);
    int (*upgrade) (cib_t *cib, int call_options);
    int (*bump_epoch) (cib_t *cib, int call_options);
    int (*create) (cib_t *cib, const char *section, xmlNode *data,
                   int call_options);
    int (*modify) (cib_t *cib, const char *section, xmlNode *data,
                   int call_options);
 
    int (*update) (cib_t *cib, const char *section, xmlNode *data,
                   int call_options);
 
    int (*replace) (cib_t *cib, const char *section, xmlNode *data,
                    int call_options);
    int (*remove) (cib_t *cib, const char *section, xmlNode *data,
                   int call_options);
    int (*erase) (cib_t *cib, xmlNode **output_data, int call_options);
 
    int (*delete_absolute) (cib_t *cib, const char *section, xmlNode *data,
                            int call_options);
 
    int (*quit) (cib_t *cib, int call_options);
 
    int (*register_notification) (cib_t *cib, const char *callback,
                                  int enabled);
    gboolean (*register_callback) (cib_t *cib, int call_id, int timeout,
                                   gboolean only_success, void *user_data,
                                   const char *callback_name,
                                   void (*callback) (xmlNode*, int, int,
                                                     xmlNode*, void *));
    gboolean (*register_callback_full)(cib_t *cib, int call_id, int timeout,
                                       gboolean only_success, void *user_data,
                                       const char *callback_name,
                                       void (*callback)(xmlNode *, int, int,
                                                        xmlNode *, void *),
                                       void (*free_func)(void *));
 
    int (*set_primary)(cib_t *cib, int call_options);
 
    int (*set_secondary)(cib_t *cib, int call_options);
 
    int (*client_id)(const cib_t *cib, const char **async_id,
                     const char **sync_id);
 
    int (*init_transaction)(cib_t *cib);
 
    int (*end_transaction)(cib_t *cib, bool commit, int call_options);
 
    void (*set_user)(cib_t *cib, const char *user);
} cib_api_operations_t;
 
struct cib_s {
    enum cib_state state;
    enum cib_conn_type type;
    enum cib_variant variant;
 
    int call_id;
    int call_timeout;
    void *variant_opaque;
    void *delegate_fn;
 
    GList *notify_list;
 
    void (*op_callback) (const xmlNode *msg, int call_id, int rc,
                         xmlNode *output);
 
    cib_api_operations_t *cmds;
 
    xmlNode *transaction;
 
    char *user;
};
 
#ifdef __cplusplus
}
#endif
 
#endif // PCMK__CRM_CIB_CIB_TYPES__H