root/include/crm/pengine/internal.h

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

INCLUDED FROM


DEFINITIONS

This source file includes following definitions.
  1. pe__rsc_bool_str
  2. pe__current_node
  3. pe_hash_table_lookup
  4. pe_base_name_eq

   1 /*
   2  * Copyright 2004-2021 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 PE_INTERNAL__H
  11 #  define PE_INTERNAL__H
  12 #  include <string.h>
  13 #  include <crm/pengine/status.h>
  14 #  include <crm/pengine/remote_internal.h>
  15 #  include <crm/common/internal.h>
  16 #  include <crm/common/output_internal.h>
  17 
  18 #  define pe_rsc_info(rsc, fmt, args...)  crm_log_tag(LOG_INFO,  rsc ? rsc->id : "<NULL>", fmt, ##args)
  19 #  define pe_rsc_debug(rsc, fmt, args...) crm_log_tag(LOG_DEBUG, rsc ? rsc->id : "<NULL>", fmt, ##args)
  20 #  define pe_rsc_trace(rsc, fmt, args...) crm_log_tag(LOG_TRACE, rsc ? rsc->id : "<NULL>", fmt, ##args)
  21 
  22 #  define pe_err(fmt...) do {           \
  23         was_processing_error = TRUE;    \
  24         pcmk__config_err(fmt);          \
  25     } while (0)
  26 
  27 #  define pe_warn(fmt...) do {          \
  28         was_processing_warning = TRUE;  \
  29         pcmk__config_warn(fmt);         \
  30     } while (0)
  31 
  32 #  define pe_proc_err(fmt...) { was_processing_error = TRUE; crm_err(fmt); }
  33 #  define pe_proc_warn(fmt...) { was_processing_warning = TRUE; crm_warn(fmt); }
  34 
  35 #define pe__set_working_set_flags(working_set, flags_to_set) do {           \
  36         (working_set)->flags = pcmk__set_flags_as(__func__, __LINE__,       \
  37             LOG_TRACE, "Working set", crm_system_name,                      \
  38             (working_set)->flags, (flags_to_set), #flags_to_set);           \
  39     } while (0)
  40 
  41 #define pe__clear_working_set_flags(working_set, flags_to_clear) do {       \
  42         (working_set)->flags = pcmk__clear_flags_as(__func__, __LINE__,     \
  43             LOG_TRACE, "Working set", crm_system_name,                      \
  44             (working_set)->flags, (flags_to_clear), #flags_to_clear);       \
  45     } while (0)
  46 
  47 #define pe__set_resource_flags(resource, flags_to_set) do {                 \
  48         (resource)->flags = pcmk__set_flags_as(__func__, __LINE__,          \
  49             LOG_TRACE, "Resource", (resource)->id, (resource)->flags,       \
  50             (flags_to_set), #flags_to_set);                                 \
  51     } while (0)
  52 
  53 #define pe__clear_resource_flags(resource, flags_to_clear) do {             \
  54         (resource)->flags = pcmk__clear_flags_as(__func__, __LINE__,        \
  55             LOG_TRACE, "Resource", (resource)->id, (resource)->flags,       \
  56             (flags_to_clear), #flags_to_clear);                             \
  57     } while (0)
  58 
  59 #define pe__set_action_flags(action, flags_to_set) do {                     \
  60         (action)->flags = pcmk__set_flags_as(__func__, __LINE__,            \
  61                                              LOG_TRACE,                     \
  62                                              "Action", (action)->uuid,      \
  63                                              (action)->flags,               \
  64                                              (flags_to_set),                \
  65                                              #flags_to_set);                \
  66     } while (0)
  67 
  68 #define pe__clear_action_flags(action, flags_to_clear) do {                 \
  69         (action)->flags = pcmk__clear_flags_as(__func__, __LINE__,          \
  70                                                LOG_TRACE,                   \
  71                                                "Action", (action)->uuid,    \
  72                                                (action)->flags,             \
  73                                                (flags_to_clear),            \
  74                                                #flags_to_clear);            \
  75     } while (0)
  76 
  77 #define pe__set_raw_action_flags(action_flags, action_name, flags_to_set) do { \
  78         action_flags = pcmk__set_flags_as(__func__, __LINE__,               \
  79                                           LOG_TRACE, "Action", action_name, \
  80                                           (action_flags),                   \
  81                                           (flags_to_set), #flags_to_set);   \
  82     } while (0)
  83 
  84 #define pe__clear_raw_action_flags(action_flags, action_name, flags_to_clear) do { \
  85         action_flags = pcmk__clear_flags_as(__func__, __LINE__,             \
  86                                             LOG_TRACE,                      \
  87                                             "Action", action_name,          \
  88                                             (action_flags),                 \
  89                                             (flags_to_clear),               \
  90                                             #flags_to_clear);               \
  91     } while (0)
  92 
  93 #define pe__set_action_flags_as(function, line, action, flags_to_set) do {  \
  94         (action)->flags = pcmk__set_flags_as((function), (line),            \
  95                                              LOG_TRACE,                     \
  96                                              "Action", (action)->uuid,      \
  97                                              (action)->flags,               \
  98                                              (flags_to_set),                \
  99                                              #flags_to_set);                \
 100     } while (0)
 101 
 102 #define pe__clear_action_flags_as(function, line, action, flags_to_clear) do { \
 103         (action)->flags = pcmk__clear_flags_as((function), (line),          \
 104                                                LOG_TRACE,                   \
 105                                                "Action", (action)->uuid,    \
 106                                                (action)->flags,             \
 107                                                (flags_to_clear),            \
 108                                                #flags_to_clear);            \
 109     } while (0)
 110 
 111 #define pe__set_order_flags(order_flags, flags_to_set) do {                 \
 112         order_flags = pcmk__set_flags_as(__func__, __LINE__, LOG_TRACE,     \
 113                                          "Ordering", "constraint",          \
 114                                          order_flags, (flags_to_set),       \
 115                                          #flags_to_set);                    \
 116     } while (0)
 117 
 118 #define pe__clear_order_flags(order_flags, flags_to_clear) do {               \
 119         order_flags = pcmk__clear_flags_as(__func__, __LINE__, LOG_TRACE,     \
 120                                            "Ordering", "constraint",          \
 121                                            order_flags, (flags_to_clear),     \
 122                                            #flags_to_clear);                  \
 123     } while (0)
 124 
 125 #define pe__set_graph_flags(graph_flags, gr_action, flags_to_set) do {      \
 126         graph_flags = pcmk__set_flags_as(__func__, __LINE__,                \
 127                                          LOG_TRACE, "Graph",                \
 128                                          (gr_action)->uuid, graph_flags,    \
 129                                          (flags_to_set), #flags_to_set);    \
 130     } while (0)
 131 
 132 #define pe__clear_graph_flags(graph_flags, gr_action, flags_to_clear) do {     \
 133         graph_flags = pcmk__clear_flags_as(__func__, __LINE__,                 \
 134                                            LOG_TRACE, "Graph",                 \
 135                                            (gr_action)->uuid, graph_flags,     \
 136                                            (flags_to_clear), #flags_to_clear); \
 137     } while (0)
 138 
 139 // Some warnings we don't want to print every transition
 140 
 141 enum pe_warn_once_e {
 142     pe_wo_blind         = (1 << 0),
 143     pe_wo_restart_type  = (1 << 1),
 144     pe_wo_role_after    = (1 << 2),
 145     pe_wo_poweroff      = (1 << 3),
 146     pe_wo_require_all   = (1 << 4),
 147     pe_wo_order_score   = (1 << 5),
 148     pe_wo_neg_threshold = (1 << 6),
 149     pe_wo_remove_after  = (1 << 7),
 150 };
 151 
 152 extern uint32_t pe_wo;
 153 
 154 #define pe_warn_once(pe_wo_bit, fmt...) do {    \
 155         if (!pcmk_is_set(pe_wo, pe_wo_bit)) {  \
 156             if (pe_wo_bit == pe_wo_blind) {     \
 157                 crm_warn(fmt);                  \
 158             } else {                            \
 159                 pe_warn(fmt);                   \
 160             }                                   \
 161             pe_wo = pcmk__set_flags_as(__func__, __LINE__, LOG_TRACE,       \
 162                                       "Warn-once", "logging", pe_wo,        \
 163                                       (pe_wo_bit), #pe_wo_bit);             \
 164         }                                       \
 165     } while (0);
 166 
 167 
 168 typedef struct pe__location_constraint_s {
 169     char *id;                           // Constraint XML ID
 170     pe_resource_t *rsc_lh;              // Resource being located
 171     enum rsc_role_e role_filter;        // Role to locate
 172     enum pe_discover_e discover_mode;   // Resource discovery
 173     GList *node_list_rh;              // List of pe_node_t*
 174 } pe__location_t;
 175 
 176 typedef struct pe__order_constraint_s {
 177     int id;
 178     enum pe_ordering type;
 179 
 180     void *lh_opaque;
 181     pe_resource_t *lh_rsc;
 182     pe_action_t *lh_action;
 183     char *lh_action_task;
 184 
 185     void *rh_opaque;
 186     pe_resource_t *rh_rsc;
 187     pe_action_t *rh_action;
 188     char *rh_action_task;
 189 } pe__ordering_t;
 190 
 191 typedef struct notify_data_s {
 192     GSList *keys;               // Environment variable name/value pairs
 193 
 194     const char *action;
 195 
 196     pe_action_t *pre;
 197     pe_action_t *post;
 198     pe_action_t *pre_done;
 199     pe_action_t *post_done;
 200 
 201     GList *active;            /* notify_entry_t*  */
 202     GList *inactive;          /* notify_entry_t*  */
 203     GList *start;             /* notify_entry_t*  */
 204     GList *stop;              /* notify_entry_t*  */
 205     GList *demote;            /* notify_entry_t*  */
 206     GList *promote;           /* notify_entry_t*  */
 207     GList *promoted;          /* notify_entry_t*  */
 208     GList *unpromoted;        /* notify_entry_t*  */
 209     GHashTable *allowed_nodes;
 210 
 211 } notify_data_t;
 212 
 213 bool pe_can_fence(pe_working_set_t *data_set, pe_node_t *node);
 214 
 215 int pe__add_scores(int score1, int score2);
 216 void add_hash_param(GHashTable * hash, const char *name, const char *value);
 217 
 218 char *native_parameter(pe_resource_t * rsc, pe_node_t * node, gboolean create, const char *name,
 219                        pe_working_set_t * data_set);
 220 pe_node_t *native_location(const pe_resource_t *rsc, GList **list, int current);
 221 
 222 void pe_metadata(void);
 223 void verify_pe_options(GHashTable * options);
 224 
 225 void common_update_score(pe_resource_t * rsc, const char *id, int score);
 226 void native_add_running(pe_resource_t * rsc, pe_node_t * node, pe_working_set_t * data_set, gboolean failed);
 227 
 228 gboolean native_unpack(pe_resource_t * rsc, pe_working_set_t * data_set);
 229 gboolean group_unpack(pe_resource_t * rsc, pe_working_set_t * data_set);
 230 gboolean clone_unpack(pe_resource_t * rsc, pe_working_set_t * data_set);
 231 gboolean pe__unpack_bundle(pe_resource_t *rsc, pe_working_set_t *data_set);
 232 
 233 pe_resource_t *native_find_rsc(pe_resource_t *rsc, const char *id, const pe_node_t *node,
 234                                int flags);
 235 
 236 gboolean native_active(pe_resource_t * rsc, gboolean all);
 237 gboolean group_active(pe_resource_t * rsc, gboolean all);
 238 gboolean clone_active(pe_resource_t * rsc, gboolean all);
 239 gboolean pe__bundle_active(pe_resource_t *rsc, gboolean all);
 240 
 241 void native_print(pe_resource_t * rsc, const char *pre_text, long options, void *print_data);
 242 void group_print(pe_resource_t * rsc, const char *pre_text, long options, void *print_data);
 243 void clone_print(pe_resource_t * rsc, const char *pre_text, long options, void *print_data);
 244 void pe__print_bundle(pe_resource_t *rsc, const char *pre_text, long options,
 245                       void *print_data);
 246 
 247 gchar * pcmk__native_output_string(pe_resource_t *rsc, const char *name, pe_node_t *node,
 248                                    unsigned long show_opts, const char *target_role, bool show_nodes);
 249 
 250 int pe__name_and_nvpairs_xml(pcmk__output_t *out, bool is_list, const char *tag_name
 251                          , size_t pairs_count, ...);
 252 char *pe__node_display_name(pe_node_t *node, bool print_detail);
 253 
 254 static inline const char *
 255 pe__rsc_bool_str(pe_resource_t *rsc, uint64_t rsc_flag)
     /* [previous][next][first][last][top][bottom][index][help] */
 256 {
 257     return pcmk__btoa(pcmk_is_set(rsc->flags, rsc_flag));
 258 }
 259 
 260 int pe__clone_xml(pcmk__output_t *out, va_list args);
 261 int pe__clone_default(pcmk__output_t *out, va_list args);
 262 int pe__group_xml(pcmk__output_t *out, va_list args);
 263 int pe__group_default(pcmk__output_t *out, va_list args);
 264 int pe__bundle_xml(pcmk__output_t *out, va_list args);
 265 int pe__bundle_html(pcmk__output_t *out, va_list args);
 266 int pe__bundle_text(pcmk__output_t *out, va_list args);
 267 int pe__node_html(pcmk__output_t *out, va_list args);
 268 int pe__node_text(pcmk__output_t *out, va_list args);
 269 int pe__node_xml(pcmk__output_t *out, va_list args);
 270 int pe__resource_xml(pcmk__output_t *out, va_list args);
 271 int pe__resource_html(pcmk__output_t *out, va_list args);
 272 int pe__resource_text(pcmk__output_t *out, va_list args);
 273 
 274 void native_free(pe_resource_t * rsc);
 275 void group_free(pe_resource_t * rsc);
 276 void clone_free(pe_resource_t * rsc);
 277 void pe__free_bundle(pe_resource_t *rsc);
 278 
 279 enum rsc_role_e native_resource_state(const pe_resource_t * rsc, gboolean current);
 280 enum rsc_role_e group_resource_state(const pe_resource_t * rsc, gboolean current);
 281 enum rsc_role_e clone_resource_state(const pe_resource_t * rsc, gboolean current);
 282 enum rsc_role_e pe__bundle_resource_state(const pe_resource_t *rsc,
 283                                           gboolean current);
 284 
 285 void pe__count_common(pe_resource_t *rsc);
 286 void pe__count_bundle(pe_resource_t *rsc);
 287 
 288 gboolean common_unpack(xmlNode * xml_obj, pe_resource_t ** rsc, pe_resource_t * parent,
 289                        pe_working_set_t * data_set);
 290 void common_free(pe_resource_t * rsc);
 291 
 292 pe_node_t *pe__copy_node(const pe_node_t *this_node);
 293 extern time_t get_effective_time(pe_working_set_t * data_set);
 294 
 295 /* Failure handling utilities (from failcounts.c) */
 296 
 297 // bit flags for fail count handling options
 298 enum pe_fc_flags_e {
 299     pe_fc_default   = (1 << 0),
 300     pe_fc_effective = (1 << 1), // don't count expired failures
 301     pe_fc_fillers   = (1 << 2), // if container, include filler failures in count
 302 };
 303 
 304 int pe_get_failcount(pe_node_t *node, pe_resource_t *rsc, time_t *last_failure,
 305                      uint32_t flags, xmlNode *xml_op,
 306                      pe_working_set_t *data_set);
 307 
 308 pe_action_t *pe__clear_failcount(pe_resource_t *rsc, pe_node_t *node,
 309                                  const char *reason,
 310                                  pe_working_set_t *data_set);
 311 
 312 /* Functions for finding/counting a resource's active nodes */
 313 
 314 pe_node_t *pe__find_active_on(const pe_resource_t *rsc,
 315                               unsigned int *count_all,
 316                               unsigned int *count_clean);
 317 pe_node_t *pe__find_active_requires(const pe_resource_t *rsc,
 318                                     unsigned int *count);
 319 
 320 static inline pe_node_t *
 321 pe__current_node(const pe_resource_t *rsc)
     /* [previous][next][first][last][top][bottom][index][help] */
 322 {
 323     return pe__find_active_on(rsc, NULL, NULL);
 324 }
 325 
 326 
 327 /* Binary like operators for lists of nodes */
 328 extern void node_list_exclude(GHashTable * list, GList *list2, gboolean merge_scores);
 329 
 330 GHashTable *pe__node_list2table(GList *list);
 331 
 332 static inline gpointer
 333 pe_hash_table_lookup(GHashTable * hash, gconstpointer key)
     /* [previous][next][first][last][top][bottom][index][help] */
 334 {
 335     if (hash) {
 336         return g_hash_table_lookup(hash, key);
 337     }
 338     return NULL;
 339 }
 340 
 341 extern pe_action_t *get_pseudo_op(const char *name, pe_working_set_t * data_set);
 342 extern gboolean order_actions(pe_action_t * lh_action, pe_action_t * rh_action, enum pe_ordering order);
 343 
 344 /* Printing functions for debug */
 345 extern void print_str_str(gpointer key, gpointer value, gpointer user_data);
 346 extern void pe__output_node(pe_node_t * node, gboolean details, pcmk__output_t *out);
 347 
 348 void pe__show_node_weights_as(const char *file, const char *function,
 349                               int line, bool to_log, pe_resource_t *rsc,
 350                               const char *comment, GHashTable *nodes,
 351                               pe_working_set_t *data_set);
 352 
 353 #define pe__show_node_weights(level, rsc, text, nodes, data_set)    \
 354         pe__show_node_weights_as(__FILE__, __func__, __LINE__,      \
 355                                  (level), (rsc), (text), (nodes), (data_set))
 356 
 357 /* Sorting functions */
 358 extern gint sort_rsc_priority(gconstpointer a, gconstpointer b);
 359 extern gint sort_rsc_index(gconstpointer a, gconstpointer b);
 360 
 361 extern xmlNode *find_rsc_op_entry(pe_resource_t * rsc, const char *key);
 362 
 363 extern pe_action_t *custom_action(pe_resource_t * rsc, char *key, const char *task, pe_node_t * on_node,
 364                                   gboolean optional, gboolean foo, pe_working_set_t * data_set);
 365 
 366 #  define delete_key(rsc) pcmk__op_key(rsc->id, CRMD_ACTION_DELETE, 0)
 367 #  define delete_action(rsc, node, optional) custom_action(             \
 368                 rsc, delete_key(rsc), CRMD_ACTION_DELETE, node,         \
 369                 optional, TRUE, data_set);
 370 
 371 #  define stopped_key(rsc) pcmk__op_key(rsc->id, CRMD_ACTION_STOPPED, 0)
 372 #  define stopped_action(rsc, node, optional) custom_action(            \
 373                 rsc, stopped_key(rsc), CRMD_ACTION_STOPPED, node,       \
 374                 optional, TRUE, data_set);
 375 
 376 #  define stop_key(rsc) pcmk__op_key(rsc->id, CRMD_ACTION_STOP, 0)
 377 #  define stop_action(rsc, node, optional) custom_action(                       \
 378                 rsc, stop_key(rsc), CRMD_ACTION_STOP, node,             \
 379                 optional, TRUE, data_set);
 380 
 381 #  define reload_key(rsc) pcmk__op_key(rsc->id, CRMD_ACTION_RELOAD_AGENT, 0)
 382 #  define start_key(rsc) pcmk__op_key(rsc->id, CRMD_ACTION_START, 0)
 383 #  define start_action(rsc, node, optional) custom_action(              \
 384                 rsc, start_key(rsc), CRMD_ACTION_START, node,           \
 385                 optional, TRUE, data_set)
 386 
 387 #  define started_key(rsc) pcmk__op_key(rsc->id, CRMD_ACTION_STARTED, 0)
 388 #  define started_action(rsc, node, optional) custom_action(            \
 389                 rsc, started_key(rsc), CRMD_ACTION_STARTED, node,       \
 390                 optional, TRUE, data_set)
 391 
 392 #  define promote_key(rsc) pcmk__op_key(rsc->id, CRMD_ACTION_PROMOTE, 0)
 393 #  define promote_action(rsc, node, optional) custom_action(            \
 394                 rsc, promote_key(rsc), CRMD_ACTION_PROMOTE, node,       \
 395                 optional, TRUE, data_set)
 396 
 397 #  define promoted_key(rsc) pcmk__op_key(rsc->id, CRMD_ACTION_PROMOTED, 0)
 398 #  define promoted_action(rsc, node, optional) custom_action(           \
 399                 rsc, promoted_key(rsc), CRMD_ACTION_PROMOTED, node,     \
 400                 optional, TRUE, data_set)
 401 
 402 #  define demote_key(rsc) pcmk__op_key(rsc->id, CRMD_ACTION_DEMOTE, 0)
 403 #  define demote_action(rsc, node, optional) custom_action(             \
 404                 rsc, demote_key(rsc), CRMD_ACTION_DEMOTE, node,         \
 405                 optional, TRUE, data_set)
 406 
 407 #  define demoted_key(rsc) pcmk__op_key(rsc->id, CRMD_ACTION_DEMOTED, 0)
 408 #  define demoted_action(rsc, node, optional) custom_action(            \
 409                 rsc, demoted_key(rsc), CRMD_ACTION_DEMOTED, node,       \
 410                 optional, TRUE, data_set)
 411 
 412 extern int pe_get_configured_timeout(pe_resource_t *rsc, const char *action,
 413                                      pe_working_set_t *data_set);
 414 
 415 extern pe_action_t *find_first_action(GList *input, const char *uuid, const char *task,
 416                                       pe_node_t * on_node);
 417 extern enum action_tasks get_complex_task(pe_resource_t * rsc, const char *name,
 418                                           gboolean allow_non_atomic);
 419 
 420 extern GList *find_actions(GList *input, const char *key, const pe_node_t *on_node);
 421 GList *find_actions_exact(GList *input, const char *key,
 422                           const pe_node_t *on_node);
 423 extern GList *find_recurring_actions(GList *input, pe_node_t * not_on_node);
 424 GList *pe__resource_actions(const pe_resource_t *rsc, const pe_node_t *node,
 425                             const char *task, bool require_node);
 426 
 427 extern void pe_free_action(pe_action_t * action);
 428 
 429 extern void resource_location(pe_resource_t * rsc, pe_node_t * node, int score, const char *tag,
 430                               pe_working_set_t * data_set);
 431 
 432 extern gint sort_op_by_callid(gconstpointer a, gconstpointer b);
 433 extern gboolean get_target_role(pe_resource_t * rsc, enum rsc_role_e *role);
 434 void pe__set_next_role(pe_resource_t *rsc, enum rsc_role_e role,
 435                        const char *why);
 436 
 437 extern pe_resource_t *find_clone_instance(pe_resource_t * rsc, const char *sub_id,
 438                                           pe_working_set_t * data_set);
 439 
 440 extern void destroy_ticket(gpointer data);
 441 extern pe_ticket_t *ticket_new(const char *ticket_id, pe_working_set_t * data_set);
 442 
 443 // Resources for manipulating resource names
 444 const char *pe_base_name_end(const char *id);
 445 char *clone_strip(const char *last_rsc_id);
 446 char *clone_zero(const char *last_rsc_id);
 447 
 448 static inline bool
 449 pe_base_name_eq(pe_resource_t *rsc, const char *id)
     /* [previous][next][first][last][top][bottom][index][help] */
 450 {
 451     if (id && rsc && rsc->id) {
 452         // Number of characters in rsc->id before any clone suffix
 453         size_t base_len = pe_base_name_end(rsc->id) - rsc->id + 1;
 454 
 455         return (strlen(id) == base_len) && !strncmp(id, rsc->id, base_len);
 456     }
 457     return FALSE;
 458 }
 459 
 460 int pe__target_rc_from_xml(xmlNode *xml_op);
 461 
 462 gint sort_node_uname(gconstpointer a, gconstpointer b);
 463 bool is_set_recursive(pe_resource_t * rsc, long long flag, bool any);
 464 
 465 enum rsc_digest_cmp_val {
 466     /*! Digests are the same */
 467     RSC_DIGEST_MATCH = 0,
 468     /*! Params that require a restart changed */
 469     RSC_DIGEST_RESTART,
 470     /*! Some parameter changed.  */
 471     RSC_DIGEST_ALL,
 472     /*! rsc op didn't have a digest associated with it, so
 473      *  it is unknown if parameters changed or not. */
 474     RSC_DIGEST_UNKNOWN,
 475 };
 476 
 477 typedef struct op_digest_cache_s {
 478     enum rsc_digest_cmp_val rc;
 479     xmlNode *params_all;
 480     xmlNode *params_secure;
 481     xmlNode *params_restart;
 482     char *digest_all_calc;
 483     char *digest_secure_calc;
 484     char *digest_restart_calc;
 485 } op_digest_cache_t;
 486 
 487 op_digest_cache_t *pe__calculate_digests(pe_resource_t *rsc, const char *task,
 488                                          guint *interval_ms, pe_node_t *node,
 489                                          xmlNode *xml_op, GHashTable *overrides,
 490                                          bool calc_secure,
 491                                          pe_working_set_t *data_set);
 492 
 493 void pe__free_digests(gpointer ptr);
 494 
 495 op_digest_cache_t *rsc_action_digest_cmp(pe_resource_t * rsc, xmlNode * xml_op, pe_node_t * node,
 496                                          pe_working_set_t * data_set);
 497 
 498 pe_action_t *pe_fence_op(pe_node_t * node, const char *op, bool optional, const char *reason, bool priority_delay, pe_working_set_t * data_set);
 499 void trigger_unfencing(
 500     pe_resource_t * rsc, pe_node_t *node, const char *reason, pe_action_t *dependency, pe_working_set_t * data_set);
 501 
 502 char *pe__action2reason(pe_action_t *action, enum pe_action_flags flag);
 503 void pe_action_set_reason(pe_action_t *action, const char *reason, bool overwrite);
 504 
 505 void pe__set_resource_flags_recursive(pe_resource_t *rsc, uint64_t flags);
 506 void pe__clear_resource_flags_recursive(pe_resource_t *rsc, uint64_t flags);
 507 void pe__clear_resource_flags_on_all(pe_working_set_t *data_set, uint64_t flag);
 508 
 509 gboolean add_tag_ref(GHashTable * tags, const char * tag_name,  const char * obj_ref);
 510 
 511 void print_rscs_brief(GList *rsc_list, const char * pre_text, long options,
 512                       void * print_data, gboolean print_all);
 513 int pe__rscs_brief_output(pcmk__output_t *out, GList *rsc_list, unsigned int options);
 514 void pe_fence_node(pe_working_set_t * data_set, pe_node_t * node, const char *reason, bool priority_delay);
 515 
 516 pe_node_t *pe_create_node(const char *id, const char *uname, const char *type,
 517                           const char *score, pe_working_set_t * data_set);
 518 void common_print(pe_resource_t * rsc, const char *pre_text, const char *name, pe_node_t *node, long options, void *print_data);
 519 int pe__common_output_text(pcmk__output_t *out, pe_resource_t * rsc, const char *name, pe_node_t *node, unsigned int options);
 520 int pe__common_output_html(pcmk__output_t *out, pe_resource_t * rsc, const char *name, pe_node_t *node, unsigned int options);
 521 pe_resource_t *pe__find_bundle_replica(const pe_resource_t *bundle,
 522                                        const pe_node_t *node);
 523 bool pe__bundle_needs_remote_name(pe_resource_t *rsc,
 524                                   pe_working_set_t *data_set);
 525 const char *pe__add_bundle_remote_name(pe_resource_t *rsc,
 526                                        pe_working_set_t *data_set,
 527                                        xmlNode *xml, const char *field);
 528 const char *pe_node_attribute_calculated(const pe_node_t *node,
 529                                          const char *name,
 530                                          const pe_resource_t *rsc);
 531 const char *pe_node_attribute_raw(pe_node_t *node, const char *name);
 532 bool pe__is_universal_clone(pe_resource_t *rsc,
 533                             pe_working_set_t *data_set);
 534 void pe__add_param_check(xmlNode *rsc_op, pe_resource_t *rsc, pe_node_t *node,
 535                          enum pe_check_parameters, pe_working_set_t *data_set);
 536 void pe__foreach_param_check(pe_working_set_t *data_set,
 537                              void (*cb)(pe_resource_t*, pe_node_t*, xmlNode*,
 538                                         enum pe_check_parameters,
 539                                         pe_working_set_t*));
 540 void pe__free_param_checks(pe_working_set_t *data_set);
 541 
 542 bool pe__shutdown_requested(pe_node_t *node);
 543 void pe__update_recheck_time(time_t recheck, pe_working_set_t *data_set);
 544 
 545 /*!
 546  * \internal
 547  * \brief Register xml formatting message functions.
 548  */
 549 void pe__register_messages(pcmk__output_t *out);
 550 
 551 void pe__unpack_dataset_nvpairs(xmlNode *xml_obj, const char *set_name,
 552                                 pe_rule_eval_data_t *rule_data, GHashTable *hash,
 553                                 const char *always_first, gboolean overwrite,
 554                                 pe_working_set_t *data_set);
 555 
 556 bool pe__resource_is_disabled(pe_resource_t *rsc);
 557 pe_action_t *pe__clear_resource_history(pe_resource_t *rsc, pe_node_t *node,
 558                                         pe_working_set_t *data_set);
 559 
 560 GList *pe__rscs_with_tag(pe_working_set_t *data_set, const char *tag_name);
 561 GList *pe__unames_with_tag(pe_working_set_t *data_set, const char *tag_name);
 562 bool pe__rsc_has_tag(pe_working_set_t *data_set, const char *rsc, const char *tag);
 563 bool pe__uname_has_tag(pe_working_set_t *data_set, const char *node, const char *tag);
 564 
 565 bool pe__rsc_running_on_any(pe_resource_t *rsc, GList *node_list);
 566 GList *pe__filter_rsc_list(GList *rscs, GList *filter);
 567 GList * pe__build_node_name_list(pe_working_set_t *data_set, const char *s);
 568 GList * pe__build_rsc_list(pe_working_set_t *data_set, const char *s);
 569 
 570 bool pcmk__rsc_filtered_by_node(pe_resource_t *rsc, GList *only_node);
 571 
 572 gboolean pe__bundle_is_filtered(pe_resource_t *rsc, GList *only_rsc, gboolean check_parent);
 573 gboolean pe__clone_is_filtered(pe_resource_t *rsc, GList *only_rsc, gboolean check_parent);
 574 gboolean pe__group_is_filtered(pe_resource_t *rsc, GList *only_rsc, gboolean check_parent);
 575 gboolean pe__native_is_filtered(pe_resource_t *rsc, GList *only_rsc, gboolean check_parent);
 576 
 577 #endif

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