include/crm/pengine/internal.h

/* */
This source file includes following definitions.
pe_hash_table_lookup
pe_base_name_eq
   1 /*
   2  * Copyright (C) 2004 Andrew Beekhof <andrew@beekhof.net>
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This software is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  17  */
  18 #ifndef PE_INTERNAL__H
  19 #  define PE_INTERNAL__H
  20 #  include <string.h>
  21 #  include <crm/pengine/status.h>
  22 #  include <crm/pengine/remote.h>
  23 
  24 #  define pe_rsc_info(rsc, fmt, args...)  crm_log_tag(LOG_INFO,  rsc ? rsc->id : "<NULL>", fmt, ##args)
  25 #  define pe_rsc_debug(rsc, fmt, args...) crm_log_tag(LOG_DEBUG, rsc ? rsc->id : "<NULL>", fmt, ##args)
  26 #  define pe_rsc_trace(rsc, fmt, args...) crm_log_tag(LOG_TRACE, rsc ? rsc->id : "<NULL>", fmt, ##args)
  27 
  28 #  define pe_err(fmt...) { was_processing_error = TRUE; crm_config_error = TRUE; crm_err(fmt); }
  29 #  define pe_warn(fmt...) { was_processing_warning = TRUE; crm_config_warning = TRUE; crm_warn(fmt); }
  30 #  define pe_proc_err(fmt...) { was_processing_error = TRUE; crm_err(fmt); }
  31 #  define pe_proc_warn(fmt...) { was_processing_warning = TRUE; crm_warn(fmt); }
  32 #  define pe_set_action_bit(action, bit) action->flags = crm_set_bit(__FUNCTION__, __LINE__, action->uuid, action->flags, bit)
  33 #  define pe_clear_action_bit(action, bit) action->flags = crm_clear_bit(__FUNCTION__, __LINE__, action->uuid, action->flags, bit)
  34 
  35 typedef struct notify_data_s {
  36     GHashTable *keys;
  37 
  38     const char *action;
  39 
  40     action_t *pre;
  41     action_t *post;
  42     action_t *pre_done;
  43     action_t *post_done;
  44 
  45     GListPtr active;            /* notify_entry_t*  */
  46     GListPtr inactive;          /* notify_entry_t*  */
  47     GListPtr start;             /* notify_entry_t*  */
  48     GListPtr stop;              /* notify_entry_t*  */
  49     GListPtr demote;            /* notify_entry_t*  */
  50     GListPtr promote;           /* notify_entry_t*  */
  51     GListPtr master;            /* notify_entry_t*  */
  52     GListPtr slave;             /* notify_entry_t*  */
  53     GHashTable *allowed_nodes;
  54 
  55 } notify_data_t;
  56 
  57 bool pe_can_fence(pe_working_set_t *data_set, node_t *node);
  58 
  59 int merge_weights(int w1, int w2);
  60 void add_hash_param(GHashTable * hash, const char *name, const char *value);
  61 void append_hashtable(gpointer key, gpointer value, gpointer user_data);
  62 
  63 char *native_parameter(resource_t * rsc, node_t * node, gboolean create, const char *name,
  64                        pe_working_set_t * data_set);
  65 node_t *native_location(resource_t * rsc, GListPtr * list, gboolean current);
  66 
  67 void pe_metadata(void);
  68 void verify_pe_options(GHashTable * options);
  69 
  70 void common_update_score(resource_t * rsc, const char *id, int score);
  71 void native_add_running(resource_t * rsc, node_t * node, pe_working_set_t * data_set);
  72 node_t *rsc_known_on(resource_t * rsc, GListPtr * list);
  73 
  74 gboolean native_unpack(resource_t * rsc, pe_working_set_t * data_set);
  75 gboolean group_unpack(resource_t * rsc, pe_working_set_t * data_set);
  76 gboolean clone_unpack(resource_t * rsc, pe_working_set_t * data_set);
  77 gboolean master_unpack(resource_t * rsc, pe_working_set_t * data_set);
  78 gboolean container_unpack(resource_t * rsc, pe_working_set_t * data_set);
  79 
  80 resource_t *native_find_rsc(resource_t * rsc, const char *id, node_t * node, int flags);
  81 
  82 gboolean native_active(resource_t * rsc, gboolean all);
  83 gboolean group_active(resource_t * rsc, gboolean all);
  84 gboolean clone_active(resource_t * rsc, gboolean all);
  85 gboolean master_active(resource_t * rsc, gboolean all);
  86 gboolean container_active(resource_t * rsc, gboolean all);
  87 
  88 void native_print(resource_t * rsc, const char *pre_text, long options, void *print_data);
  89 void group_print(resource_t * rsc, const char *pre_text, long options, void *print_data);
  90 void clone_print(resource_t * rsc, const char *pre_text, long options, void *print_data);
  91 void master_print(resource_t * rsc, const char *pre_text, long options, void *print_data);
  92 void container_print(resource_t * rsc, const char *pre_text, long options, void *print_data);
  93 
  94 void native_free(resource_t * rsc);
  95 void group_free(resource_t * rsc);
  96 void clone_free(resource_t * rsc);
  97 void master_free(resource_t * rsc);
  98 void container_free(resource_t * rsc);
  99 
 100 enum rsc_role_e native_resource_state(const resource_t * rsc, gboolean current);
 101 enum rsc_role_e group_resource_state(const resource_t * rsc, gboolean current);
 102 enum rsc_role_e clone_resource_state(const resource_t * rsc, gboolean current);
 103 enum rsc_role_e master_resource_state(const resource_t * rsc, gboolean current);
 104 enum rsc_role_e container_resource_state(const resource_t * rsc, gboolean current);
 105 
 106 gboolean common_unpack(xmlNode * xml_obj, resource_t ** rsc, resource_t * parent,
 107                        pe_working_set_t * data_set);
 108 void common_free(resource_t * rsc);
 109 
 110 extern pe_working_set_t *pe_dataset;
 111 
 112 extern node_t *node_copy(const node_t *this_node);
 113 extern time_t get_effective_time(pe_working_set_t * data_set);
 114 
 115 /* Failure handling utilities (from failcounts.c) */
 116 
 117 // bit flags for fail count handling options
 118 enum pe_fc_flags_e {
 119     pe_fc_default   = 0x00,
 120     pe_fc_effective = 0x01, // don't count expired failures
 121     pe_fc_fillers   = 0x02, // if container, include filler failures in count
 122 };
 123 
 124 int pe_get_failcount(node_t *node, resource_t *rsc, time_t *last_failure,
 125                      uint32_t flags, xmlNode *xml_op,
 126                      pe_working_set_t *data_set);
 127 
 128 /* Binary like operators for lists of nodes */
 129 extern void node_list_exclude(GHashTable * list, GListPtr list2, gboolean merge_scores);
 130 extern GListPtr node_list_dup(GListPtr list, gboolean reset, gboolean filter);
 131 extern GListPtr node_list_from_hash(GHashTable * hash, gboolean reset, gboolean filter);
 132 
 133 extern GHashTable *node_hash_from_list(GListPtr list);
 134 static inline gpointer
 135 pe_hash_table_lookup(GHashTable * hash, gconstpointer key)
     /*  */
 136 {
 137     if (hash) {
 138         return g_hash_table_lookup(hash, key);
 139     }
 140     return NULL;
 141 }
 142 
 143 extern action_t *get_pseudo_op(const char *name, pe_working_set_t * data_set);
 144 extern gboolean order_actions(action_t * lh_action, action_t * rh_action, enum pe_ordering order);
 145 
 146 GHashTable *node_hash_dup(GHashTable * hash);
 147 extern GListPtr node_list_and(GListPtr list1, GListPtr list2, gboolean filter);
 148 
 149 extern GListPtr node_list_xor(GListPtr list1, GListPtr list2, gboolean filter);
 150 
 151 extern GListPtr node_list_minus(GListPtr list1, GListPtr list2, gboolean filter);
 152 
 153 extern void pe_free_shallow(GListPtr alist);
 154 extern void pe_free_shallow_adv(GListPtr alist, gboolean with_data);
 155 
 156 /* Printing functions for debug */
 157 extern void print_node(const char *pre_text, node_t * node, gboolean details);
 158 
 159 extern void print_resource(int log_level, const char *pre_text, resource_t * rsc, gboolean details);
 160 
 161 extern void dump_node_scores_worker(int level, const char *file, const char *function, int line,
 162                                     resource_t * rsc, const char *comment, GHashTable * nodes);
 163 
 164 extern void dump_node_capacity(int level, const char *comment, node_t * node);
 165 extern void dump_rsc_utilization(int level, const char *comment, resource_t * rsc, node_t * node);
 166 
 167 #  define dump_node_scores(level, rsc, text, nodes) do {                \
 168         dump_node_scores_worker(level, __FILE__, __FUNCTION__, __LINE__, rsc, text, nodes); \
 169     } while(0)
 170 
 171 /* Sorting functions */
 172 extern gint sort_rsc_priority(gconstpointer a, gconstpointer b);
 173 extern gint sort_rsc_index(gconstpointer a, gconstpointer b);
 174 
 175 extern xmlNode *find_rsc_op_entry(resource_t * rsc, const char *key);
 176 
 177 extern action_t *custom_action(resource_t * rsc, char *key, const char *task, node_t * on_node,
 178                                gboolean optional, gboolean foo, pe_working_set_t * data_set);
 179 
 180 #  define delete_key(rsc) generate_op_key(rsc->id, CRMD_ACTION_DELETE, 0)
 181 #  define delete_action(rsc, node, optional) custom_action(             \
 182                 rsc, delete_key(rsc), CRMD_ACTION_DELETE, node,         \
 183                 optional, TRUE, data_set);
 184 
 185 #  define stopped_key(rsc) generate_op_key(rsc->id, CRMD_ACTION_STOPPED, 0)
 186 #  define stopped_action(rsc, node, optional) custom_action(            \
 187                 rsc, stopped_key(rsc), CRMD_ACTION_STOPPED, node,       \
 188                 optional, TRUE, data_set);
 189 
 190 #  define stop_key(rsc) generate_op_key(rsc->id, CRMD_ACTION_STOP, 0)
 191 #  define stop_action(rsc, node, optional) custom_action(                       \
 192                 rsc, stop_key(rsc), CRMD_ACTION_STOP, node,             \
 193                 optional, TRUE, data_set);
 194 
 195 #  define reload_key(rsc) generate_op_key(rsc->id, CRMD_ACTION_RELOAD, 0)
 196 #  define start_key(rsc) generate_op_key(rsc->id, CRMD_ACTION_START, 0)
 197 #  define start_action(rsc, node, optional) custom_action(              \
 198                 rsc, start_key(rsc), CRMD_ACTION_START, node,           \
 199                 optional, TRUE, data_set)
 200 
 201 #  define started_key(rsc) generate_op_key(rsc->id, CRMD_ACTION_STARTED, 0)
 202 #  define started_action(rsc, node, optional) custom_action(            \
 203                 rsc, started_key(rsc), CRMD_ACTION_STARTED, node,       \
 204                 optional, TRUE, data_set)
 205 
 206 #  define promote_key(rsc) generate_op_key(rsc->id, CRMD_ACTION_PROMOTE, 0)
 207 #  define promote_action(rsc, node, optional) custom_action(            \
 208                 rsc, promote_key(rsc), CRMD_ACTION_PROMOTE, node,       \
 209                 optional, TRUE, data_set)
 210 
 211 #  define promoted_key(rsc) generate_op_key(rsc->id, CRMD_ACTION_PROMOTED, 0)
 212 #  define promoted_action(rsc, node, optional) custom_action(           \
 213                 rsc, promoted_key(rsc), CRMD_ACTION_PROMOTED, node,     \
 214                 optional, TRUE, data_set)
 215 
 216 #  define demote_key(rsc) generate_op_key(rsc->id, CRMD_ACTION_DEMOTE, 0)
 217 #  define demote_action(rsc, node, optional) custom_action(             \
 218                 rsc, demote_key(rsc), CRMD_ACTION_DEMOTE, node,         \
 219                 optional, TRUE, data_set)
 220 
 221 #  define demoted_key(rsc) generate_op_key(rsc->id, CRMD_ACTION_DEMOTED, 0)
 222 #  define demoted_action(rsc, node, optional) custom_action(            \
 223                 rsc, demoted_key(rsc), CRMD_ACTION_DEMOTED, node,       \
 224                 optional, TRUE, data_set)
 225 
 226 extern int pe_get_configured_timeout(resource_t *rsc, const char *action,
 227                                      pe_working_set_t *data_set);
 228 
 229 extern action_t *find_first_action(GListPtr input, const char *uuid, const char *task,
 230                                    node_t * on_node);
 231 extern enum action_tasks get_complex_task(resource_t * rsc, const char *name,
 232                                           gboolean allow_non_atomic);
 233 
 234 extern GListPtr find_actions(GListPtr input, const char *key, const node_t *on_node);
 235 extern GListPtr find_actions_exact(GListPtr input, const char *key, node_t * on_node);
 236 extern GListPtr find_recurring_actions(GListPtr input, node_t * not_on_node);
 237 
 238 extern void pe_free_action(action_t * action);
 239 
 240 extern void resource_location(resource_t * rsc, node_t * node, int score, const char *tag,
 241                               pe_working_set_t * data_set);
 242 
 243 extern gint sort_op_by_callid(gconstpointer a, gconstpointer b);
 244 extern gboolean get_target_role(resource_t * rsc, enum rsc_role_e *role);
 245 
 246 extern resource_t *find_clone_instance(resource_t * rsc, const char *sub_id,
 247                                        pe_working_set_t * data_set);
 248 
 249 extern void destroy_ticket(gpointer data);
 250 extern ticket_t *ticket_new(const char *ticket_id, pe_working_set_t * data_set);
 251 
 252 // Resources for manipulating resource names
 253 const char *pe_base_name_end(const char *id);
 254 char *clone_strip(const char *last_rsc_id);
 255 char *clone_zero(const char *last_rsc_id);
 256 
 257 static inline bool
 258 pe_base_name_eq(resource_t *rsc, const char *id)
     /*  */
 259 {
 260     if (id && rsc && rsc->id) {
 261         // Number of characters in rsc->id before any clone suffix
 262         size_t base_len = pe_base_name_end(rsc->id) - rsc->id + 1;
 263 
 264         return (strlen(id) == base_len) && !strncmp(id, rsc->id, base_len);
 265     }
 266     return FALSE;
 267 }
 268 
 269 int get_target_rc(xmlNode * xml_op);
 270 
 271 gint sort_node_uname(gconstpointer a, gconstpointer b);
 272 bool is_set_recursive(resource_t * rsc, long long flag, bool any);
 273 
 274 enum rsc_digest_cmp_val {
 275     /*! Digests are the same */
 276     RSC_DIGEST_MATCH = 0,
 277     /*! Params that require a restart changed */
 278     RSC_DIGEST_RESTART,
 279     /*! Some parameter changed.  */
 280     RSC_DIGEST_ALL,
 281     /*! rsc op didn't have a digest associated with it, so
 282      *  it is unknown if parameters changed or not. */
 283     RSC_DIGEST_UNKNOWN,
 284 };
 285 
 286 typedef struct op_digest_cache_s {
 287     enum rsc_digest_cmp_val rc;
 288     xmlNode *params_all;
 289     xmlNode *params_secure;
 290     xmlNode *params_restart;
 291     char *digest_all_calc;
 292     char *digest_secure_calc;
 293     char *digest_restart_calc;
 294 } op_digest_cache_t;
 295 
 296 op_digest_cache_t *rsc_action_digest_cmp(resource_t * rsc, xmlNode * xml_op, node_t * node,
 297                                          pe_working_set_t * data_set);
 298 
 299 action_t *pe_fence_op(node_t * node, const char *op, bool optional, const char *reason, pe_working_set_t * data_set);
 300 void trigger_unfencing(
 301     resource_t * rsc, node_t *node, const char *reason, action_t *dependency, pe_working_set_t * data_set);
 302 
 303 void pe_action_set_reason(pe_action_t *action, const char *reason, bool overwrite);
 304 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);
 305 
 306 #define pe_action_required(action, reason, text) pe_action_set_flag_reason(__FUNCTION__, __LINE__, action, reason, text, pe_action_optional, FALSE)
 307 #define pe_action_implies(action, reason, flag) pe_action_set_flag_reason(__FUNCTION__, __LINE__, action, reason, NULL, flag, FALSE)
 308 
 309 void set_bit_recursive(resource_t * rsc, unsigned long long flag);
 310 void clear_bit_recursive(resource_t * rsc, unsigned long long flag);
 311 
 312 gboolean add_tag_ref(GHashTable * tags, const char * tag_name,  const char * obj_ref);
 313 
 314 void print_rscs_brief(GListPtr rsc_list, const char * pre_text, long options,
 315                       void * print_data, gboolean print_all);
 316 void pe_fence_node(pe_working_set_t * data_set, node_t * node, const char *reason);
 317 
 318 node_t *pe_create_node(const char *id, const char *uname, const char *type,
 319                        const char *score, pe_working_set_t * data_set);
 320 bool remote_id_conflict(const char *remote_name, pe_working_set_t *data);
 321 void common_print(resource_t * rsc, const char *pre_text, const char *name, node_t *node, long options, void *print_data);
 322 resource_t *find_container_child(const char *stem, resource_t * rsc, node_t *node);
 323 bool container_fix_remote_addr(resource_t *rsc);
 324 const char *container_fix_remote_addr_in(resource_t *rsc, xmlNode *xml, const char *field);
 325 const char *pe_node_attribute_calculated(pe_node_t *node, const char *name, resource_t *rsc);
 326 const char *pe_node_attribute_raw(pe_node_t *node, const char *name);
 327 
 328 #endif
/* */
root/include/crm/pengine/internal.h

INCLUDED FROM

DEFINITIONS
