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 *
pe__rsc_bool_str(pe_resource_t * rsc,uint64_t rsc_flag)255 pe__rsc_bool_str(pe_resource_t *rsc, uint64_t rsc_flag)
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 *
pe__current_node(const pe_resource_t * rsc)321 pe__current_node(const pe_resource_t *rsc)
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
pe_hash_table_lookup(GHashTable * hash,gconstpointer key)333 pe_hash_table_lookup(GHashTable * hash, gconstpointer key)
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
pe_base_name_eq(pe_resource_t * rsc,const char * id)449 pe_base_name_eq(pe_resource_t *rsc, const char *id)
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 void pe_action_set_reason(pe_action_t *action, const char *reason, bool overwrite);
503 void pe_action_set_flag_reason(const char *function, long line, pe_action_t *action, pe_action_t *reason, const char *text, enum pe_action_flags flags, bool overwrite);
504
505 #define pe_action_required(action, reason, text) \
506 pe_action_set_flag_reason(__func__, __LINE__, action, reason, text, \
507 pe_action_optional, FALSE)
508 #define pe_action_implies(action, reason, flag) \
509 pe_action_set_flag_reason(__func__, __LINE__, action, reason, NULL, \
510 flag, FALSE)
511
512 void pe__set_resource_flags_recursive(pe_resource_t *rsc, uint64_t flags);
513 void pe__clear_resource_flags_recursive(pe_resource_t *rsc, uint64_t flags);
514 void pe__clear_resource_flags_on_all(pe_working_set_t *data_set, uint64_t flag);
515
516 gboolean add_tag_ref(GHashTable * tags, const char * tag_name, const char * obj_ref);
517
518 void print_rscs_brief(GList *rsc_list, const char * pre_text, long options,
519 void * print_data, gboolean print_all);
520 int pe__rscs_brief_output(pcmk__output_t *out, GList *rsc_list, unsigned int options);
521 void pe_fence_node(pe_working_set_t * data_set, pe_node_t * node, const char *reason, bool priority_delay);
522
523 pe_node_t *pe_create_node(const char *id, const char *uname, const char *type,
524 const char *score, pe_working_set_t * data_set);
525 void common_print(pe_resource_t * rsc, const char *pre_text, const char *name, pe_node_t *node, long options, void *print_data);
526 int pe__common_output_text(pcmk__output_t *out, pe_resource_t * rsc, const char *name, pe_node_t *node, unsigned int options);
527 int pe__common_output_html(pcmk__output_t *out, pe_resource_t * rsc, const char *name, pe_node_t *node, unsigned int options);
528 pe_resource_t *pe__find_bundle_replica(const pe_resource_t *bundle,
529 const pe_node_t *node);
530 bool pe__bundle_needs_remote_name(pe_resource_t *rsc,
531 pe_working_set_t *data_set);
532 const char *pe__add_bundle_remote_name(pe_resource_t *rsc,
533 pe_working_set_t *data_set,
534 xmlNode *xml, const char *field);
535 const char *pe_node_attribute_calculated(const pe_node_t *node,
536 const char *name,
537 const pe_resource_t *rsc);
538 const char *pe_node_attribute_raw(pe_node_t *node, const char *name);
539 bool pe__is_universal_clone(pe_resource_t *rsc,
540 pe_working_set_t *data_set);
541 void pe__add_param_check(xmlNode *rsc_op, pe_resource_t *rsc, pe_node_t *node,
542 enum pe_check_parameters, pe_working_set_t *data_set);
543 void pe__foreach_param_check(pe_working_set_t *data_set,
544 void (*cb)(pe_resource_t*, pe_node_t*, xmlNode*,
545 enum pe_check_parameters,
546 pe_working_set_t*));
547 void pe__free_param_checks(pe_working_set_t *data_set);
548
549 bool pe__shutdown_requested(pe_node_t *node);
550 void pe__update_recheck_time(time_t recheck, pe_working_set_t *data_set);
551
552 /*!
553 * \internal
554 * \brief Register xml formatting message functions.
555 */
556 void pe__register_messages(pcmk__output_t *out);
557
558 void pe__unpack_dataset_nvpairs(xmlNode *xml_obj, const char *set_name,
559 pe_rule_eval_data_t *rule_data, GHashTable *hash,
560 const char *always_first, gboolean overwrite,
561 pe_working_set_t *data_set);
562
563 bool pe__resource_is_disabled(pe_resource_t *rsc);
564 pe_action_t *pe__clear_resource_history(pe_resource_t *rsc, pe_node_t *node,
565 pe_working_set_t *data_set);
566
567 GList *pe__rscs_with_tag(pe_working_set_t *data_set, const char *tag_name);
568 GList *pe__unames_with_tag(pe_working_set_t *data_set, const char *tag_name);
569 bool pe__rsc_has_tag(pe_working_set_t *data_set, const char *rsc, const char *tag);
570 bool pe__uname_has_tag(pe_working_set_t *data_set, const char *node, const char *tag);
571
572 bool pe__rsc_running_on_any(pe_resource_t *rsc, GList *node_list);
573 GList *pe__filter_rsc_list(GList *rscs, GList *filter);
574 GList * pe__build_node_name_list(pe_working_set_t *data_set, const char *s);
575 GList * pe__build_rsc_list(pe_working_set_t *data_set, const char *s);
576
577 bool pcmk__rsc_filtered_by_node(pe_resource_t *rsc, GList *only_node);
578
579 gboolean pe__bundle_is_filtered(pe_resource_t *rsc, GList *only_rsc, gboolean check_parent);
580 gboolean pe__clone_is_filtered(pe_resource_t *rsc, GList *only_rsc, gboolean check_parent);
581 gboolean pe__group_is_filtered(pe_resource_t *rsc, GList *only_rsc, gboolean check_parent);
582 gboolean pe__native_is_filtered(pe_resource_t *rsc, GList *only_rsc, gboolean check_parent);
583
584 #endif
585