root/include/crm/pengine/pe_types.h

/* */

INCLUDED FROM

   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_TYPES__H
  11 #  define PE_TYPES__H
  12 
  13 #ifdef __cplusplus
  14 extern "C" {
  15 #endif
  16 
  17 /*!
  18  * \file
  19  * \brief Data types for cluster status
  20  * \ingroup pengine
  21  */
  22 
  23 #  include <stdbool.h>              // bool
  24 #  include <sys/types.h>            // time_t
  25 #  include <libxml/tree.h>          // xmlNode
  26 #  include <glib.h>                 // gboolean, guint, GList, GHashTable
  27 #  include <crm/common/iso8601.h>
  28 #  include <crm/pengine/common.h>
  29 
  30 typedef struct pe_node_s pe_node_t;
  31 typedef struct pe_action_s pe_action_t;
  32 typedef struct pe_resource_s pe_resource_t;
  33 typedef struct pe_working_set_s pe_working_set_t;
  34 
  35 enum pe_obj_types {
  36     pe_unknown = -1,
  37     pe_native = 0,
  38     pe_group = 1,
  39     pe_clone = 2,
  40     pe_container = 3,
  41 };
  42 
  43 typedef struct resource_object_functions_s {
  44     gboolean (*unpack) (pe_resource_t*, pe_working_set_t*);
  45     pe_resource_t *(*find_rsc) (pe_resource_t *parent, const char *search,
  46                                 const pe_node_t *node, int flags);
  47     /* parameter result must be free'd */
  48     char *(*parameter) (pe_resource_t*, pe_node_t*, gboolean, const char*,
  49                         pe_working_set_t*);
  50     //! \deprecated will be removed in a future release
  51     void (*print) (pe_resource_t*, const char*, long, void*);
  52     gboolean (*active) (pe_resource_t*, gboolean);
  53     enum rsc_role_e (*state) (const pe_resource_t*, gboolean);
  54     pe_node_t *(*location) (const pe_resource_t*, GList**, int);
  55     void (*free) (pe_resource_t*);
  56     void (*count) (pe_resource_t*);
  57     gboolean (*is_filtered) (pe_resource_t*, GList *, gboolean);
  58 } resource_object_functions_t;
  59 
  60 typedef struct resource_alloc_functions_s resource_alloc_functions_t;
  61 
  62 enum pe_quorum_policy {
  63     no_quorum_freeze,
  64     no_quorum_stop,
  65     no_quorum_ignore,
  66     no_quorum_suicide,
  67     no_quorum_demote
  68 };
  69 
  70 enum node_type {
  71     node_ping,
  72     node_member,
  73     node_remote
  74 };
  75 
  76 //! \deprecated will be removed in a future release
  77 enum pe_restart {
  78     pe_restart_restart,
  79     pe_restart_ignore
  80 };
  81 
  82 //! Determine behavior of pe_find_resource_with_flags()
  83 enum pe_find {
  84     pe_find_renamed  = 0x001, //!< match resource ID or LRM history ID
  85     pe_find_anon     = 0x002, //!< match base name of anonymous clone instances
  86     pe_find_clone    = 0x004, //!< match only clone instances
  87     pe_find_current  = 0x008, //!< match resource active on specified node
  88     pe_find_inactive = 0x010, //!< match resource not running anywhere
  89     pe_find_any      = 0x020, //!< match base name of any clone instance
  90 };
  91 
  92 // @TODO Make these an enum
  93 
  94 #  define pe_flag_have_quorum           0x00000001ULL
  95 #  define pe_flag_symmetric_cluster     0x00000002ULL
  96 #  define pe_flag_maintenance_mode      0x00000008ULL
  97 
  98 #  define pe_flag_stonith_enabled       0x00000010ULL
  99 #  define pe_flag_have_stonith_resource 0x00000020ULL
 100 #  define pe_flag_enable_unfencing      0x00000040ULL
 101 #  define pe_flag_concurrent_fencing    0x00000080ULL
 102 
 103 #  define pe_flag_stop_rsc_orphans      0x00000100ULL
 104 #  define pe_flag_stop_action_orphans   0x00000200ULL
 105 #  define pe_flag_stop_everything       0x00000400ULL
 106 
 107 #  define pe_flag_start_failure_fatal   0x00001000ULL
 108 
 109 //! \deprecated
 110 #  define pe_flag_remove_after_stop     0x00002000ULL
 111 
 112 #  define pe_flag_startup_fencing       0x00004000ULL
 113 #  define pe_flag_shutdown_lock         0x00008000ULL
 114 
 115 #  define pe_flag_startup_probes        0x00010000ULL
 116 #  define pe_flag_have_status           0x00020000ULL
 117 #  define pe_flag_have_remote_nodes     0x00040000ULL
 118 
 119 #  define pe_flag_quick_location        0x00100000ULL
 120 #  define pe_flag_sanitized             0x00200000ULL
 121 
 122 //! \deprecated
 123 #  define pe_flag_stdout                0x00400000ULL
 124 
 125 //! Don't count total, disabled and blocked resource instances
 126 #  define pe_flag_no_counts             0x00800000ULL
 127 
 128 /*! Skip deprecated code that is kept solely for backward API compatibility.
 129  * (Internal code should always set this.)
 130  */
 131 #  define pe_flag_no_compat             0x01000000ULL
 132 
 133 #  define pe_flag_show_scores           0x02000000ULL
 134 #  define pe_flag_show_utilization      0x04000000ULL
 135 
 136 struct pe_working_set_s {
 137     xmlNode *input;
 138     crm_time_t *now;
 139 
 140     /* options extracted from the input */
 141     char *dc_uuid;
 142     pe_node_t *dc_node;
 143     const char *stonith_action;
 144     const char *placement_strategy;
 145 
 146     unsigned long long flags;
 147 
 148     int stonith_timeout;
 149     enum pe_quorum_policy no_quorum_policy;
 150 
 151     GHashTable *config_hash;
 152     GHashTable *tickets;
 153 
 154     // Actions for which there can be only one (e.g. fence nodeX)
 155     GHashTable *singletons;
 156 
 157     GList *nodes;
 158     GList *resources;
 159     GList *placement_constraints;
 160     GList *ordering_constraints;
 161     GList *colocation_constraints;
 162     GList *ticket_constraints;
 163 
 164     GList *actions;
 165     xmlNode *failed;
 166     xmlNode *op_defaults;
 167     xmlNode *rsc_defaults;
 168 
 169     /* stats */
 170     int num_synapse;
 171     int max_valid_nodes;    //! Deprecated (will be removed in a future release)
 172     int order_id;
 173     int action_id;
 174 
 175     /* final output */
 176     xmlNode *graph;
 177 
 178     GHashTable *template_rsc_sets;
 179     const char *localhost;
 180     GHashTable *tags;
 181 
 182     int blocked_resources;
 183     int disabled_resources;
 184 
 185     GList *param_check; // History entries that need to be checked
 186     GList *stop_needed; // Containers that need stop actions
 187     time_t recheck_by;  // Hint to controller to re-run scheduler by this time
 188     int ninstances;     // Total number of resource instances
 189     guint shutdown_lock;// How long (seconds) to lock resources to shutdown node
 190     int priority_fencing_delay; // Priority fencing delay
 191 
 192     void *priv;
 193 };
 194 
 195 enum pe_check_parameters {
 196     /* Clear fail count if parameters changed for un-expired start or monitor
 197      * last_failure.
 198      */
 199     pe_check_last_failure,
 200 
 201     /* Clear fail count if parameters changed for start, monitor, promote, or
 202      * migrate_from actions for active resources.
 203      */
 204     pe_check_active,
 205 };
 206 
 207 struct pe_node_shared_s {
 208     const char *id;
 209     const char *uname;
 210     enum node_type type;
 211 
 212     /* @TODO convert these flags into a bitfield */
 213     gboolean online;
 214     gboolean standby;
 215     gboolean standby_onfail;
 216     gboolean pending;
 217     gboolean unclean;
 218     gboolean unseen;
 219     gboolean shutdown;
 220     gboolean expected_up;
 221     gboolean is_dc;
 222     gboolean maintenance;
 223     gboolean rsc_discovery_enabled;
 224     gboolean remote_requires_reset;
 225     gboolean remote_was_fenced;
 226     gboolean remote_maintenance; /* what the remote-rsc is thinking */
 227     gboolean unpacked;
 228 
 229     int num_resources;
 230     pe_resource_t *remote_rsc;
 231     GList *running_rsc;       /* pe_resource_t* */
 232     GList *allocated_rsc;     /* pe_resource_t* */
 233 
 234     GHashTable *attrs;          /* char* => char* */
 235     GHashTable *utilization;
 236     GHashTable *digest_cache;   //!< cache of calculated resource digests
 237     int priority; // calculated based on the priority of resources running on the node
 238 };
 239 
 240 struct pe_node_s {
 241     int weight;
 242     gboolean fixed;
 243     int count;
 244     struct pe_node_shared_s *details;
 245     int rsc_discover_mode;
 246 };
 247 
 248 #  define pe_rsc_orphan                     0x00000001ULL
 249 #  define pe_rsc_managed                    0x00000002ULL
 250 #  define pe_rsc_block                      0x00000004ULL
 251 #  define pe_rsc_orphan_container_filler    0x00000008ULL
 252 
 253 #  define pe_rsc_notify                     0x00000010ULL
 254 #  define pe_rsc_unique                     0x00000020ULL
 255 #  define pe_rsc_fence_device               0x00000040ULL
 256 #  define pe_rsc_promotable                 0x00000080ULL
 257 
 258 #  define pe_rsc_provisional                0x00000100ULL
 259 #  define pe_rsc_allocating                 0x00000200ULL
 260 #  define pe_rsc_merging                    0x00000400ULL
 261 
 262 #  define pe_rsc_stop                       0x00001000ULL
 263 #  define pe_rsc_reload                     0x00002000ULL
 264 #  define pe_rsc_allow_remote_remotes       0x00004000ULL
 265 #  define pe_rsc_critical                   0x00008000ULL
 266 
 267 #  define pe_rsc_failed                     0x00010000ULL
 268 #  define pe_rsc_runnable                   0x00040000ULL
 269 #  define pe_rsc_start_pending              0x00080000ULL
 270 
 271 #  define pe_rsc_starting                   0x00100000ULL
 272 #  define pe_rsc_stopping                   0x00200000ULL
 273 #  define pe_rsc_allow_migrate              0x00800000ULL
 274 
 275 #  define pe_rsc_failure_ignored            0x01000000ULL
 276 #  define pe_rsc_maintenance                0x04000000ULL
 277 #  define pe_rsc_is_container               0x08000000ULL
 278 
 279 #  define pe_rsc_needs_quorum               0x10000000ULL
 280 #  define pe_rsc_needs_fencing              0x20000000ULL
 281 #  define pe_rsc_needs_unfencing            0x40000000ULL
 282 
 283 enum pe_graph_flags {
 284     pe_graph_none = 0x00000,
 285     pe_graph_updated_first = 0x00001,
 286     pe_graph_updated_then = 0x00002,
 287     pe_graph_disable = 0x00004,
 288 };
 289 
 290 /* *INDENT-OFF* */
 291 enum pe_action_flags {
 292     pe_action_pseudo = 0x00001,
 293     pe_action_runnable = 0x00002,
 294     pe_action_optional = 0x00004,
 295     pe_action_print_always = 0x00008,
 296 
 297     pe_action_have_node_attrs = 0x00010,
 298     pe_action_implied_by_stonith = 0x00040,
 299     pe_action_migrate_runnable =   0x00080,
 300 
 301     pe_action_dumped = 0x00100,
 302     pe_action_processed = 0x00200,
 303 #if !defined(PCMK_ALLOW_DEPRECATED) || (PCMK_ALLOW_DEPRECATED == 1)
 304     pe_action_clear = 0x00400, //! \deprecated Unused
 305 #endif
 306     pe_action_dangle = 0x00800,
 307 
 308     /* This action requires one or more of its dependencies to be runnable.
 309      * We use this to clear the runnable flag before checking dependencies.
 310      */
 311     pe_action_requires_any = 0x01000,
 312 
 313     pe_action_reschedule = 0x02000,
 314     pe_action_tracking = 0x04000,
 315     pe_action_dedup = 0x08000, //! Internal state tracking when creating graph
 316 
 317     pe_action_dc = 0x10000,         //! Action may run on DC instead of target
 318 };
 319 /* *INDENT-ON* */
 320 
 321 struct pe_resource_s {
 322     char *id;
 323     char *clone_name;
 324     xmlNode *xml;
 325     xmlNode *orig_xml;
 326     xmlNode *ops_xml;
 327 
 328     pe_working_set_t *cluster;
 329     pe_resource_t *parent;
 330 
 331     enum pe_obj_types variant;
 332     void *variant_opaque;
 333     resource_object_functions_t *fns;
 334     resource_alloc_functions_t *cmds;
 335 
 336     enum rsc_recovery_type recovery_type;
 337 
 338     // @TODO only pe_restart_restart is of interest, so merge into flags
 339     enum pe_restart restart_type; //!< \deprecated will be removed in future release
 340 
 341     int priority;
 342     int stickiness;
 343     int sort_index;
 344     int failure_timeout;
 345     int migration_threshold;
 346     guint remote_reconnect_ms;
 347     char *pending_task;
 348 
 349     unsigned long long flags;
 350 
 351     // @TODO merge these into flags
 352     gboolean is_remote_node;
 353     gboolean exclusive_discover;
 354 
 355     //!@{
 356     //! This field should be treated as internal to Pacemaker
 357     GList *rsc_cons_lhs;      // List of pcmk__colocation_t*
 358     GList *rsc_cons;          // List of pcmk__colocation_t*
 359     GList *rsc_location;      // List of pe__location_t*
 360     GList *actions;           // List of pe_action_t*
 361     GList *rsc_tickets;       // List of rsc_ticket*
 362     //!@}
 363 
 364     pe_node_t *allocated_to;
 365     pe_node_t *partial_migration_target;
 366     pe_node_t *partial_migration_source;
 367     GList *running_on;        /* pe_node_t*   */
 368     GHashTable *known_on;       /* pe_node_t*   */
 369     GHashTable *allowed_nodes;  /* pe_node_t*   */
 370 
 371     enum rsc_role_e role;
 372     enum rsc_role_e next_role;
 373 
 374     GHashTable *meta;
 375     GHashTable *parameters; //! \deprecated Use pe_rsc_params() instead
 376     GHashTable *utilization;
 377 
 378     GList *children;          /* pe_resource_t*   */
 379     GList *dangling_migrations;       /* pe_node_t*       */
 380 
 381     pe_resource_t *container;
 382     GList *fillers;
 383 
 384     pe_node_t *pending_node;    // Node on which pending_task is happening
 385     pe_node_t *lock_node;       // Resource is shutdown-locked to this node
 386     time_t lock_time;           // When shutdown lock started
 387 
 388     /* Resource parameters may have node-attribute-based rules, which means the
 389      * values can vary by node. This table is a cache of parameter name/value
 390      * tables for each node (as needed). Use pe_rsc_params() to get the table
 391      * for a given node.
 392      */
 393     GHashTable *parameter_cache; // Key = node name, value = parameters table
 394 #if ENABLE_VERSIONED_ATTRS
 395     xmlNode *versioned_parameters;
 396 #endif
 397 };
 398 
 399 #if ENABLE_VERSIONED_ATTRS
 400 // Used as action->action_details if action->rsc is not NULL
 401 typedef struct pe_rsc_action_details_s {
 402     xmlNode *versioned_parameters;
 403     xmlNode *versioned_meta;
 404 } pe_rsc_action_details_t;
 405 #endif
 406 
 407 struct pe_action_s {
 408     int id;
 409     int priority;
 410 
 411     pe_resource_t *rsc;
 412     pe_node_t *node;
 413     xmlNode *op_entry;
 414 
 415     char *task;
 416     char *uuid;
 417     char *cancel_task;
 418     char *reason;
 419 
 420     enum pe_action_flags flags;
 421     enum rsc_start_requirement needs;
 422     enum action_fail_response on_fail;
 423     enum rsc_role_e fail_role;
 424 
 425     GHashTable *meta;
 426     GHashTable *extra;
 427 
 428     /* 
 429      * These two varables are associated with the constraint logic
 430      * that involves first having one or more actions runnable before
 431      * then allowing this action to execute.
 432      *
 433      * These varables are used with features such as 'clone-min' which
 434      * requires at minimum X number of cloned instances to be running
 435      * before an order dependency can run. Another option that uses
 436      * this is 'require-all=false' in ordering constrants. This option
 437      * says "only require one instance of a resource to start before
 438      * allowing dependencies to start" -- basically, require-all=false is
 439      * the same as clone-min=1.
 440      */
 441 
 442     /* current number of known runnable actions in the before list. */
 443     int runnable_before;
 444     /* the number of "before" runnable actions required for this action
 445      * to be considered runnable */ 
 446     int required_runnable_before;
 447 
 448     GList *actions_before;    /* pe_action_wrapper_t* */
 449     GList *actions_after;     /* pe_action_wrapper_t* */
 450 
 451     /* Some of the above fields could be moved to the details,
 452      * except for API backward compatibility.
 453      */
 454     void *action_details; // varies by type of action
 455 };
 456 
 457 typedef struct pe_ticket_s {
 458     char *id;
 459     gboolean granted;
 460     time_t last_granted;
 461     gboolean standby;
 462     GHashTable *state;
 463 } pe_ticket_t;
 464 
 465 typedef struct pe_tag_s {
 466     char *id;
 467     GList *refs;
 468 } pe_tag_t;
 469 
 470 //! Internal tracking for transition graph creation
 471 enum pe_link_state {
 472     pe_link_not_dumped, //! Internal tracking for transition graph creation
 473     pe_link_dumped,     //! Internal tracking for transition graph creation
 474     pe_link_dup,        //! \deprecated No longer used by Pacemaker
 475 };
 476 
 477 enum pe_discover_e {
 478     pe_discover_always = 0,
 479     pe_discover_never,
 480     pe_discover_exclusive,
 481 };
 482 
 483 /* *INDENT-OFF* */
 484 enum pe_ordering {
 485     pe_order_none                  = 0x0,       /* deleted */
 486     pe_order_optional              = 0x1,       /* pure ordering, nothing implied */
 487     pe_order_apply_first_non_migratable = 0x2,  /* Only apply this constraint's ordering if first is not migratable. */
 488 
 489     pe_order_implies_first         = 0x10,      /* If 'then' is required, ensure 'first' is too */
 490     pe_order_implies_then          = 0x20,      /* If 'first' is required, ensure 'then' is too */
 491     pe_order_promoted_implies_first = 0x40,     /* If 'then' is required and then's rsc is promoted, ensure 'first' becomes required too */
 492 
 493     /* first requires then to be both runnable and migrate runnable. */
 494     pe_order_implies_first_migratable  = 0x80,
 495 
 496     pe_order_runnable_left         = 0x100,     /* 'then' requires 'first' to be runnable */
 497 
 498     pe_order_pseudo_left           = 0x200,     /* 'then' can only be pseudo if 'first' is runnable */
 499     pe_order_implies_then_on_node  = 0x400,     /* If 'first' is required on 'nodeX',
 500                                                  * ensure instances of 'then' on 'nodeX' are too.
 501                                                  * Only really useful if 'then' is a clone and 'first' is not
 502                                                  */
 503     pe_order_probe                 = 0x800,     /* If 'first->rsc' is
 504                                                  *  - running but about to stop, ignore the constraint
 505                                                  *  - otherwise, behave as runnable_left
 506                                                  */
 507 
 508     pe_order_restart               = 0x1000,    /* 'then' is runnable if 'first' is optional or runnable */
 509     pe_order_stonith_stop          = 0x2000,    /* only applies if the action is non-pseudo */
 510     pe_order_serialize_only        = 0x4000,    /* serialize */
 511     pe_order_same_node             = 0x8000,    /* applies only if 'first' and 'then' are on same node */
 512 
 513     pe_order_implies_first_printed = 0x10000,   /* Like ..implies_first but only ensures 'first' is printed, not mandatory */
 514     pe_order_implies_then_printed  = 0x20000,   /* Like ..implies_then but only ensures 'then' is printed, not mandatory */
 515 
 516     pe_order_asymmetrical          = 0x100000,  /* Indicates asymmetrical one way ordering constraint. */
 517     pe_order_load                  = 0x200000,  /* Only relevant if... */
 518     pe_order_one_or_more           = 0x400000,  /* 'then' is runnable only if one or more of its dependencies are too */
 519     pe_order_anti_colocation       = 0x800000,
 520 
 521     pe_order_preserve              = 0x1000000, /* Hack for breaking user ordering constraints with container resources */
 522     pe_order_then_cancels_first    = 0x2000000, // if 'then' becomes required, 'first' becomes optional
 523     pe_order_trace                 = 0x4000000, /* test marker */
 524 
 525 #if !defined(PCMK_ALLOW_DEPRECATED) || (PCMK_ALLOW_DEPRECATED == 1)
 526     // \deprecated Use pe_order_promoted_implies_first instead
 527     pe_order_implies_first_master  = pe_order_promoted_implies_first,
 528 #endif
 529 };
 530 /* *INDENT-ON* */
 531 
 532 typedef struct pe_action_wrapper_s {
 533     enum pe_ordering type;
 534     enum pe_link_state state;
 535     pe_action_t *action;
 536 } pe_action_wrapper_t;
 537 
 538 #if !defined(PCMK_ALLOW_DEPRECATED) || (PCMK_ALLOW_DEPRECATED == 1)
 539 #include <crm/pengine/pe_types_compat.h>
 540 #endif
 541 
 542 #ifdef __cplusplus
 543 }
 544 #endif
 545 
 546 #endif // PE_TYPES__H

/* */