pacemaker.h

Go to the documentation of this file.

/*
 * Copyright 2019-2022 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, char *dest_node, 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_pacemakerd_status(xmlNodePtr *xml, const char *ipc_name,
                           unsigned int message_timeout_ms);
 
int pcmk_resource_digests(xmlNodePtr *xml, pe_resource_t *rsc,
                          pe_node_t *node, GHashTable *overrides,
                          pe_working_set_t *data_set);
 
int pcmk_simulate(xmlNodePtr *xml, pe_working_set_t *data_set,
                  pcmk_injections_t *injections, unsigned int flags,
                  unsigned int section_opts, char *use_date, char *input_file,
                  char *graph_file, char *dot_file);
 
int pcmk_list_nodes(xmlNodePtr *xml, 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
 * \brief Bit flags to control which fields of result code info are displayed
 */
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),   
};
 
/*
 * \brief Display the name and/or description of a result code
 *
 * \param[in,out] xml    The destination for the result, as an XML tree
 * \param[in]     code   The result code
 * \param[in]     type   Interpret \c code as this type of result code.
 *                       Supported values: \c pcmk_result_legacy,
 *                       \c pcmk_result_rc, \c pcmk_result_exitcode.
 * \param[in]     flags  Group of \c pcmk_rc_disp_flags
 *
 * \return Standard Pacemaker return code
 */
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, 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, char *agent,
                        unsigned int timeout);
 
int pcmk_fence_registered(xmlNodePtr *xml, stonith_t *st, char *target,
                          unsigned int timeout);
 
int pcmk_fence_register_level(stonith_t *st, char *target, int fence_level,
                              stonith_key_value_t *devices);
 
int pcmk_fence_unregister_level(stonith_t *st, char *target, int fence_level);
 
int pcmk_fence_validate(xmlNodePtr *xml, stonith_t *st, const char *agent,
                        const char *id, stonith_key_value_t *params,
                        unsigned int timeout);
#endif
 
#ifdef __cplusplus
}
#endif
 
#endif