include/crm/pengine/internal.h

/* */
This source file includes following definitions.
pe_base_name_eq
pe__health_strategy
   1 /*
   2  * Copyright 2004-2025 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_PENGINE_INTERNAL__H
  11 #define PCMK__CRM_PENGINE_INTERNAL__H
  12 
  13 #include <stdbool.h>
  14 #include <stdint.h>                         // uint32_t
  15 #include <string.h>
  16 #include <crm/common/xml.h>
  17 #include <crm/pengine/status.h>
  18 #include <crm/pengine/remote_internal.h>
  19 #include <crm/common/internal.h>
  20 #include <crm/common/options_internal.h>
  21 #include <crm/common/output_internal.h>
  22 #include <crm/common/scheduler_internal.h>
  23 
  24 #ifdef __cplusplus
  25 extern "C" {
  26 #endif
  27 
  28 const char *pe__resource_description(const pcmk_resource_t *rsc,
  29                                      uint32_t show_opts);
  30 
  31 bool pe__clone_is_ordered(const pcmk_resource_t *clone);
  32 int pe__set_clone_flag(pcmk_resource_t *clone, enum pcmk__clone_flags flag);
  33 bool pe__clone_flag_is_set(const pcmk_resource_t *clone, uint32_t flags);
  34 
  35 bool pe__group_flag_is_set(const pcmk_resource_t *group, uint32_t flags);
  36 pcmk_resource_t *pe__last_group_member(const pcmk_resource_t *group);
  37 
  38 const pcmk_resource_t *pe__const_top_resource(const pcmk_resource_t *rsc,
  39                                               bool include_bundle);
  40 
  41 int pe__clone_max(const pcmk_resource_t *clone);
  42 int pe__clone_node_max(const pcmk_resource_t *clone);
  43 int pe__clone_promoted_max(const pcmk_resource_t *clone);
  44 int pe__clone_promoted_node_max(const pcmk_resource_t *clone);
  45 void pe__create_clone_notifications(pcmk_resource_t *clone);
  46 void pe__free_clone_notification_data(pcmk_resource_t *clone);
  47 void pe__create_clone_notif_pseudo_ops(pcmk_resource_t *clone,
  48                                        pcmk_action_t *start,
  49                                        pcmk_action_t *started,
  50                                        pcmk_action_t *stop,
  51                                        pcmk_action_t *stopped);
  52 
  53 pcmk_action_t *pe__new_rsc_pseudo_action(pcmk_resource_t *rsc, const char *task,
  54                                          bool optional, bool runnable);
  55 
  56 void pe__create_promotable_pseudo_ops(pcmk_resource_t *clone,
  57                                       bool any_promoting, bool any_demoting);
  58 
  59 bool pe_can_fence(const pcmk_scheduler_t *scheduler, const pcmk_node_t *node);
  60 
  61 pcmk_node_t *native_location(const pcmk_resource_t *rsc, GList **list,
  62                              uint32_t target);
  63 void native_add_running(pcmk_resource_t *rsc, pcmk_node_t *node,
  64                         pcmk_scheduler_t *scheduler, gboolean failed);
  65 
  66 bool native_unpack(pcmk_resource_t *rsc);
  67 bool group_unpack(pcmk_resource_t *rsc);
  68 bool clone_unpack(pcmk_resource_t *rsc);
  69 bool pe__unpack_bundle(pcmk_resource_t *rsc);
  70 
  71 pcmk_resource_t *native_find_rsc(pcmk_resource_t *rsc, const char *id,
  72                                  const pcmk_node_t *node, uint32_t flags);
  73 
  74 bool native_active(const pcmk_resource_t *rsc, bool all);
  75 bool group_active(const pcmk_resource_t *rsc, bool all);
  76 bool clone_active(const pcmk_resource_t *rsc, bool all);
  77 bool pe__bundle_active(const pcmk_resource_t *rsc, bool all);
  78 
  79 gchar *pcmk__native_output_string(const pcmk_resource_t *rsc, const char *name,
  80                                   const pcmk_node_t *node, uint32_t show_opts,
  81                                   const char *target_role, bool show_nodes);
  82 
  83 int pe__name_and_nvpairs_xml(pcmk__output_t *out, bool is_list, const char *tag_name,
  84                              ...) G_GNUC_NULL_TERMINATED;
  85 char *pe__node_display_name(pcmk_node_t *node, bool print_detail);
  86 
  87 
  88 // Clone notifications (pe_notif.c)
  89 void pe__order_notifs_after_fencing(const pcmk_action_t *action,
  90                                     pcmk_resource_t *rsc,
  91                                     pcmk_action_t *stonith_op);
  92 
  93 
  94 // Resource output methods
  95 int pe__clone_xml(pcmk__output_t *out, va_list args);
  96 int pe__clone_default(pcmk__output_t *out, va_list args);
  97 int pe__group_xml(pcmk__output_t *out, va_list args);
  98 int pe__group_default(pcmk__output_t *out, va_list args);
  99 int pe__bundle_xml(pcmk__output_t *out, va_list args);
 100 int pe__bundle_html(pcmk__output_t *out, va_list args);
 101 int pe__bundle_text(pcmk__output_t *out, va_list args);
 102 int pe__node_html(pcmk__output_t *out, va_list args);
 103 int pe__node_text(pcmk__output_t *out, va_list args);
 104 int pe__node_xml(pcmk__output_t *out, va_list args);
 105 int pe__resource_xml(pcmk__output_t *out, va_list args);
 106 int pe__resource_html(pcmk__output_t *out, va_list args);
 107 int pe__resource_text(pcmk__output_t *out, va_list args);
 108 
 109 void native_free(pcmk_resource_t *rsc);
 110 void group_free(pcmk_resource_t *rsc);
 111 void clone_free(pcmk_resource_t *rsc);
 112 void pe__free_bundle(pcmk_resource_t *rsc);
 113 
 114 enum rsc_role_e native_resource_state(const pcmk_resource_t *rsc, bool current);
 115 enum rsc_role_e group_resource_state(const pcmk_resource_t *rsc, bool current);
 116 enum rsc_role_e clone_resource_state(const pcmk_resource_t *rsc, bool current);
 117 enum rsc_role_e pe__bundle_resource_state(const pcmk_resource_t *rsc,
 118                                           bool current);
 119 
 120 void pe__count_common(pcmk_resource_t *rsc);
 121 void pe__count_bundle(pcmk_resource_t *rsc);
 122 
 123 void common_free(pcmk_resource_t *rsc);
 124 
 125 pcmk_node_t *pe__copy_node(const pcmk_node_t *this_node);
 126 
 127 /* Failure handling utilities (from failcounts.c) */
 128 
 129 int pe_get_failcount(const pcmk_node_t *node, pcmk_resource_t *rsc,
 130                      time_t *last_failure, uint32_t flags,
 131                      const xmlNode *xml_op);
 132 
 133 pcmk_action_t *pe__clear_failcount(pcmk_resource_t *rsc,
 134                                    const pcmk_node_t *node, const char *reason,
 135                                    pcmk_scheduler_t *scheduler);
 136 
 137 /* Functions for finding/counting a resource's active nodes */
 138 
 139 bool pe__count_active_node(const pcmk_resource_t *rsc, pcmk_node_t *node,
 140                            pcmk_node_t **active, unsigned int *count_all,
 141                            unsigned int *count_clean);
 142 
 143 pcmk_node_t *pe__find_active_requires(const pcmk_resource_t *rsc,
 144                                     unsigned int *count);
 145 
 146 /* Binary like operators for lists of nodes */
 147 GHashTable *pe__node_list2table(const GList *list);
 148 
 149 pcmk_action_t *get_pseudo_op(const char *name, pcmk_scheduler_t *scheduler);
 150 gboolean order_actions(pcmk_action_t *first, pcmk_action_t *then,
 151                        uint32_t flags);
 152 
 153 void pe__show_node_scores_as(const char *file, const char *function,
 154                              int line, bool to_log, const pcmk_resource_t *rsc,
 155                              const char *comment, GHashTable *nodes,
 156                              pcmk_scheduler_t *scheduler);
 157 
 158 #define pe__show_node_scores(level, rsc, text, nodes, scheduler)    \
 159         pe__show_node_scores_as(__FILE__, __func__, __LINE__,      \
 160                                 (level), (rsc), (text), (nodes), (scheduler))
 161 
 162 GHashTable *pcmk__unpack_action_meta(pcmk_resource_t *rsc,
 163                                      const pcmk_node_t *node,
 164                                      const char *action_name, guint interval_ms,
 165                                      const xmlNode *action_config);
 166 GHashTable *pcmk__unpack_action_rsc_params(const xmlNode *action_xml,
 167                                            GHashTable *node_attrs,
 168                                            pcmk_scheduler_t *data_set);
 169 xmlNode *pcmk__find_action_config(const pcmk_resource_t *rsc,
 170                                   const char *action_name, guint interval_ms,
 171                                   bool include_disabled);
 172 
 173 enum pcmk__requires pcmk__action_requires(const pcmk_resource_t *rsc,
 174                                           const char *action_name);
 175 
 176 enum pcmk__on_fail pcmk__parse_on_fail(const pcmk_resource_t *rsc,
 177                                        const char *action_name,
 178                                        guint interval_ms, const char *value);
 179 
 180 enum rsc_role_e pcmk__role_after_failure(const pcmk_resource_t *rsc,
 181                                          const char *action_name,
 182                                          enum pcmk__on_fail on_fail,
 183                                          GHashTable *meta);
 184 
 185 pcmk_action_t *custom_action(pcmk_resource_t *rsc, char *key, const char *task,
 186                              const pcmk_node_t *on_node, gboolean optional,
 187                              pcmk_scheduler_t *scheduler);
 188 
 189 #define delete_key(rsc)  pcmk__op_key((rsc)->id, PCMK_ACTION_DELETE, 0)
 190 #define stop_key(rsc)    pcmk__op_key((rsc)->id, PCMK_ACTION_STOP, 0)
 191 #define reload_key(rsc)  pcmk__op_key((rsc)->id, PCMK_ACTION_RELOAD_AGENT, 0)
 192 #define start_key(rsc)   pcmk__op_key((rsc)->id, PCMK_ACTION_START, 0)
 193 #define promote_key(rsc) pcmk__op_key((rsc)->id, PCMK_ACTION_PROMOTE, 0)
 194 #define demote_key(rsc)  pcmk__op_key((rsc)->id, PCMK_ACTION_DEMOTE, 0)
 195 
 196 #define delete_action(rsc, node, optional)                          \
 197     custom_action((rsc), delete_key(rsc), PCMK_ACTION_DELETE,       \
 198                   (node), (optional), (rsc)->priv->scheduler)
 199 
 200 #define stop_action(rsc, node, optional)                            \
 201     custom_action((rsc), stop_key(rsc), PCMK_ACTION_STOP,           \
 202                   (node), (optional), (rsc)->priv->scheduler)
 203 
 204 #define start_action(rsc, node, optional)                           \
 205     custom_action((rsc), start_key(rsc), PCMK_ACTION_START,         \
 206                   (node), (optional), (rsc)->priv->scheduler)
 207 
 208 #define promote_action(rsc, node, optional)                         \
 209     custom_action((rsc), promote_key(rsc), PCMK_ACTION_PROMOTE,     \
 210                   (node), (optional), (rsc)->priv->scheduler)
 211 
 212 #define demote_action(rsc, node, optional)                          \
 213     custom_action((rsc), demote_key(rsc), PCMK_ACTION_DEMOTE,       \
 214                   (node), (optional), (rsc)->priv->scheduler)
 215 
 216 pcmk_action_t *find_first_action(const GList *input, const char *uuid,
 217                                  const char *task, const pcmk_node_t *on_node);
 218 
 219 enum pcmk__action_type get_complex_task(const pcmk_resource_t *rsc,
 220                                         const char *name);
 221 
 222 GList *find_actions(GList *input, const char *key, const pcmk_node_t *on_node);
 223 GList *find_actions_exact(GList *input, const char *key,
 224                           const pcmk_node_t *on_node);
 225 GList *pe__resource_actions(const pcmk_resource_t *rsc, const pcmk_node_t *node,
 226                             const char *task, bool require_node);
 227 
 228 void resource_location(pcmk_resource_t *rsc, const pcmk_node_t *node, int score,
 229                        const char *tag, pcmk_scheduler_t *scheduler);
 230 
 231 int pe__is_newer_op(const xmlNode *xml_a, const xmlNode *xml_b);
 232 extern gint sort_op_by_callid(gconstpointer a, gconstpointer b);
 233 gboolean get_target_role(const pcmk_resource_t *rsc, enum rsc_role_e *role);
 234 void pe__set_next_role(pcmk_resource_t *rsc, enum rsc_role_e role,
 235                        const char *why);
 236 
 237 extern void destroy_ticket(gpointer data);
 238 pcmk__ticket_t *ticket_new(const char *ticket_id, pcmk_scheduler_t *scheduler);
 239 
 240 // Resources for manipulating resource names
 241 const char *pe_base_name_end(const char *id);
 242 char *clone_strip(const char *last_rsc_id);
 243 char *clone_zero(const char *last_rsc_id);
 244 
 245 static inline bool
 246 pe_base_name_eq(const pcmk_resource_t *rsc, const char *id)
     /*  */
 247 {
 248     if (id && rsc && rsc->id) {
 249         // Number of characters in rsc->id before any clone suffix
 250         size_t base_len = pe_base_name_end(rsc->id) - rsc->id + 1;
 251 
 252         return (strlen(id) == base_len) && !strncmp(id, rsc->id, base_len);
 253     }
 254     return false;
 255 }
 256 
 257 int pe__target_rc_from_xml(const xmlNode *xml_op);
 258 
 259 gint pe__cmp_node_name(gconstpointer a, gconstpointer b);
 260 bool is_set_recursive(const pcmk_resource_t *rsc, long long flag, bool any);
 261 
 262 pcmk__op_digest_t *pe__calculate_digests(pcmk_resource_t *rsc, const char *task,
 263                                          guint *interval_ms,
 264                                          const pcmk_node_t *node,
 265                                          const xmlNode *xml_op,
 266                                          GHashTable *overrides,
 267                                          bool calc_secure,
 268                                          pcmk_scheduler_t *scheduler);
 269 
 270 void pe__free_digests(gpointer ptr);
 271 
 272 pcmk__op_digest_t *rsc_action_digest_cmp(pcmk_resource_t *rsc,
 273                                          const xmlNode *xml_op,
 274                                          pcmk_node_t *node,
 275                                          pcmk_scheduler_t *scheduler);
 276 
 277 pcmk_action_t *pe_fence_op(pcmk_node_t *node, const char *op, bool optional,
 278                            const char *reason, bool priority_delay,
 279                            pcmk_scheduler_t *scheduler);
 280 void trigger_unfencing(pcmk_resource_t *rsc, pcmk_node_t *node,
 281                        const char *reason, pcmk_action_t *dependency,
 282                        pcmk_scheduler_t *scheduler);
 283 
 284 char *pe__action2reason(const pcmk_action_t *action,
 285                         enum pcmk__action_flags flag);
 286 void pe_action_set_reason(pcmk_action_t *action, const char *reason,
 287                           bool overwrite);
 288 void pe__add_action_expected_result(pcmk_action_t *action, int expected_result);
 289 
 290 void pe__set_resource_flags_recursive(pcmk_resource_t *rsc, uint64_t flags);
 291 void pe__clear_resource_flags_recursive(pcmk_resource_t *rsc, uint64_t flags);
 292 void pe__clear_resource_flags_on_all(pcmk_scheduler_t *scheduler,
 293                                      uint64_t flag);
 294 
 295 int pe__rscs_brief_output(pcmk__output_t *out, GList *rsc_list, unsigned int options);
 296 void pe_fence_node(pcmk_scheduler_t *scheduler, pcmk_node_t *node,
 297                    const char *reason, bool priority_delay);
 298 
 299 pcmk_node_t *pe_create_node(const char *id, const char *uname, const char *type,
 300                             int score, pcmk_scheduler_t *scheduler);
 301 
 302 int pe__common_output_text(pcmk__output_t *out, const pcmk_resource_t *rsc,
 303                            const char *name, const pcmk_node_t *node,
 304                            unsigned int options);
 305 int pe__common_output_html(pcmk__output_t *out, const pcmk_resource_t *rsc,
 306                            const char *name, const pcmk_node_t *node,
 307                            unsigned int options);
 308 
 309 GList *pe__bundle_containers(const pcmk_resource_t *bundle);
 310 
 311 int pe__bundle_max(const pcmk_resource_t *rsc);
 312 bool pe__node_is_bundle_instance(const pcmk_resource_t *bundle,
 313                                  const pcmk_node_t *node);
 314 pcmk_resource_t *pe__bundled_resource(const pcmk_resource_t *rsc);
 315 const pcmk_resource_t *pe__get_rsc_in_container(const pcmk_resource_t *instance);
 316 pcmk_resource_t *pe__first_container(const pcmk_resource_t *bundle);
 317 void pe__foreach_bundle_replica(pcmk_resource_t *bundle,
 318                                 bool (*fn)(pcmk__bundle_replica_t *, void *),
 319                                 void *user_data);
 320 void pe__foreach_const_bundle_replica(const pcmk_resource_t *bundle,
 321                                       bool (*fn)(const pcmk__bundle_replica_t *,
 322                                                  void *),
 323                                       void *user_data);
 324 pcmk_resource_t *pe__find_bundle_replica(const pcmk_resource_t *bundle,
 325                                          const pcmk_node_t *node);
 326 bool pe__bundle_needs_remote_name(pcmk_resource_t *rsc);
 327 const char *pe__add_bundle_remote_name(pcmk_resource_t *rsc, xmlNode *xml,
 328                                        const char *field);
 329 bool pe__is_universal_clone(const pcmk_resource_t *rsc,
 330                             const pcmk_scheduler_t *scheduler);
 331 
 332 bool pe__shutdown_requested(const pcmk_node_t *node);
 333 
 334 /*!
 335  * \internal
 336  * \brief Register xml formatting message functions.
 337  *
 338  * \param[in,out] out  Output object to register messages with
 339  */
 340 void pe__register_messages(pcmk__output_t *out);
 341 
 342 void pe__unpack_dataset_nvpairs(const xmlNode *xml_obj, const char *set_name,
 343                                 const pcmk_rule_input_t *rule_input,
 344                                 GHashTable *hash, const char *always_first,
 345                                 pcmk_scheduler_t *scheduler);
 346 
 347 bool pe__resource_is_disabled(const pcmk_resource_t *rsc);
 348 void pe__clear_resource_history(pcmk_resource_t *rsc, const pcmk_node_t *node);
 349 
 350 GList *pe__rscs_with_tag(pcmk_scheduler_t *scheduler, const char *tag_name);
 351 GList *pe__unames_with_tag(pcmk_scheduler_t *scheduler, const char *tag_name);
 352 bool pe__rsc_has_tag(pcmk_scheduler_t *scheduler, const char *rsc,
 353                      const char *tag);
 354 bool pe__uname_has_tag(pcmk_scheduler_t *scheduler, const char *node,
 355                        const char *tag);
 356 
 357 bool pe__rsc_running_on_only(const pcmk_resource_t *rsc,
 358                              const pcmk_node_t *node);
 359 bool pe__rsc_running_on_any(pcmk_resource_t *rsc, GList *node_list);
 360 GList *pe__filter_rsc_list(GList *rscs, GList *filter);
 361 GList * pe__build_node_name_list(pcmk_scheduler_t *scheduler, const char *s);
 362 GList * pe__build_rsc_list(pcmk_scheduler_t *scheduler, const char *s);
 363 
 364 bool pcmk__rsc_filtered_by_node(pcmk_resource_t *rsc, GList *only_node);
 365 
 366 bool pe__bundle_is_filtered(const pcmk_resource_t *rsc, const GList *only_rsc,
 367                             bool check_parent);
 368 bool pe__clone_is_filtered(const pcmk_resource_t *rsc, const GList *only_rsc,
 369                            bool check_parent);
 370 bool pe__group_is_filtered(const pcmk_resource_t *rsc, const GList *only_rsc,
 371                            bool check_parent);
 372 bool pe__native_is_filtered(const pcmk_resource_t *rsc, const GList *only_rsc,
 373                             bool check_parent);
 374 
 375 xmlNode *pe__failed_probe_for_rsc(const pcmk_resource_t *rsc, const char *name);
 376 
 377 const char *pe__clone_child_id(const pcmk_resource_t *rsc);
 378 
 379 int pe__sum_node_health_scores(const pcmk_node_t *node, int base_health);
 380 int pe__node_health(pcmk_node_t *node);
 381 
 382 static inline enum pcmk__health_strategy
 383 pe__health_strategy(pcmk_scheduler_t *scheduler)
     /*  */
 384 {
 385     const char *strategy = pcmk__cluster_option(scheduler->priv->options,
 386                                                 PCMK_OPT_NODE_HEALTH_STRATEGY);
 387 
 388     return pcmk__parse_health_strategy(strategy);
 389 }
 390 
 391 #ifdef __cplusplus
 392 }
 393 #endif
 394 
 395 #endif // PCMK__CRM_PENGINE_INTERNAL__H
/* */
root/include/crm/pengine/internal.h

INCLUDED FROM

DEFINITIONS
