pacemaker.h

Go to the documentation of this file.

/*
 * Copyright 2019-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__PACEMAKER__H
#  define PCMK__PACEMAKER__H
 
#  include <glib.h>
#  include <libxml/tree.h>
#  include <crm/cib/cib_types.h>
#  include <crm/pengine/pe_types.h>
 
#  include <crm/stonith-ng.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
enum pcmk_sim_flags {
    pcmk_sim_none             = 0,
    pcmk_sim_all_actions      = 1 << 0,
    pcmk_sim_show_pending     = 1 << 1,
    pcmk_sim_process          = 1 << 2,
    pcmk_sim_show_scores      = 1 << 3,
    pcmk_sim_show_utilization = 1 << 4,
    pcmk_sim_simulate         = 1 << 5,
    pcmk_sim_sanitized        = 1 << 6,
    pcmk_sim_verbose          = 1 << 7,
};
 
typedef struct {
    GList *node_up;
    GList *node_down;
    GList *node_fail;
    GList *op_inject;
    GList *op_fail;
    GList *ticket_grant;
    GList *ticket_revoke;
    GList *ticket_standby;
    GList *ticket_activate;
    char *watchdog;
    char *quorum;
} pcmk_injections_t;
 
int pcmk_controller_status(xmlNodePtr *xml, const char *node_name,
                           unsigned int message_timeout_ms);
 
int pcmk_designated_controller(xmlNodePtr *xml,
                               unsigned int message_timeout_ms);
 
void pcmk_free_injections(pcmk_injections_t *injections);
 
int pcmk_query_node_info(xmlNodePtr *xml, uint32_t *node_id, char **node_name,
                         char **uuid, char **state, bool *have_quorum,
                         bool *is_remote, bool show_output,
                         unsigned int message_timeout_ms);
 
static inline int
pcmk_query_node_name(xmlNodePtr *xml, uint32_t node_id, char **node_name,
                     unsigned int message_timeout_ms)
{
    return pcmk_query_node_info(xml, &node_id, node_name, NULL, NULL, NULL,
                                NULL, false, message_timeout_ms);
}
 
int pcmk_pacemakerd_status(xmlNodePtr *xml, const char *ipc_name,
                           unsigned int message_timeout_ms);
 
int pcmk_resource_digests(xmlNodePtr *xml, pe_resource_t *rsc,
                          const pe_node_t *node, GHashTable *overrides,
                          pe_working_set_t *data_set);
 
int pcmk_simulate(xmlNodePtr *xml, pe_working_set_t *data_set,
                  const pcmk_injections_t *injections, unsigned int flags,
                  unsigned int section_opts, const char *use_date,
                  const char *input_file, const char *graph_file,
                  const char *dot_file);
 
int pcmk_list_nodes(xmlNodePtr *xml, const char *node_types);
 
int pcmk_status(xmlNodePtr *xml);
 
int pcmk_check_rules(xmlNodePtr *xml, xmlNodePtr input, const crm_time_t *date,
                     const char **rule_ids);
 
static inline int
pcmk_check_rule(xmlNodePtr *xml, xmlNodePtr input, const crm_time_t *date,
                const char *rule_id)
{
    const char *rule_ids[] = {rule_id, NULL};
    return pcmk_check_rules(xml, input, date, rule_ids);
}
 
enum pcmk_rc_disp_flags {
    pcmk_rc_disp_none = 0,          
    pcmk_rc_disp_code = (1 << 0),   
    pcmk_rc_disp_name = (1 << 1),   
    pcmk_rc_disp_desc = (1 << 2),   
};
 
int pcmk_show_result_code(xmlNodePtr *xml, int code, enum pcmk_result_type type,
                          uint32_t flags);
 
int pcmk_list_result_codes(xmlNodePtr *xml, enum pcmk_result_type type,
                           uint32_t flags);
 
#ifdef BUILD_PUBLIC_LIBPACEMAKER
 
int pcmk_request_fencing(stonith_t *st, const char *target, const char *action,
                         const char *name, unsigned int timeout,
                         unsigned int tolerance, int delay, char **reason);
 
int pcmk_fence_history(xmlNodePtr *xml, stonith_t *st, const char *target,
                       unsigned int timeout, bool quiet, int verbose,
                       bool broadcast, bool cleanup);
 
int pcmk_fence_installed(xmlNodePtr *xml, stonith_t *st, unsigned int timeout);
 
int pcmk_fence_last(xmlNodePtr *xml, const char *target, bool as_nodeid);
 
int pcmk_fence_list_targets(xmlNodePtr *xml, stonith_t *st,
                            const char *device_id, unsigned int timeout);
 
int pcmk_fence_metadata(xmlNodePtr *xml, stonith_t *st, const char *agent,
                        unsigned int timeout);
 
int pcmk_fence_registered(xmlNodePtr *xml, stonith_t *st, const char *target,
                          unsigned int timeout);
 
int pcmk_fence_register_level(stonith_t *st, const char *target,
                              int fence_level,
                              const stonith_key_value_t *devices);
 
int pcmk_fence_unregister_level(stonith_t *st, const char *target,
                                int fence_level);
 
int pcmk_fence_validate(xmlNodePtr *xml, stonith_t *st, const char *agent,
                        const char *id, const stonith_key_value_t *params,
                        unsigned int timeout);
#endif
 
#ifdef __cplusplus
}
#endif
 
#endif