resources.h

Go to the documentation of this file.

/*
 * Copyright 2004-2023 the Pacemaker project contributors
 *
 * The version control history for this file may have further details.
 *
 * This source code is licensed under the GNU Lesser General Public License
 * version 2.1 or later (LGPLv2.1+) WITHOUT ANY WARRANTY.
 */
 
#ifndef PCMK__CRM_COMMON_RESOURCES__H
#  define PCMK__CRM_COMMON_RESOURCES__H
 
#include <sys/types.h>                  // time_t
#include <libxml/tree.h>                // xmlNode
#include <glib.h>                       // gboolean, guint, GList, GHashTable
 
#include <crm/common/roles.h>           // enum rsc_role_e
#include <crm/common/scheduler_types.h> // pcmk_resource_t, etc.
 
#ifdef __cplusplus
extern "C" {
#endif
 
enum pe_obj_types {
    // Order matters: some code compares greater or lesser than
    pcmk_rsc_variant_unknown    = -1,   
    pcmk_rsc_variant_primitive  = 0,    
    pcmk_rsc_variant_group      = 1,    
    pcmk_rsc_variant_clone      = 2,    
    pcmk_rsc_variant_bundle     = 3,    
 
#if !defined(PCMK_ALLOW_DEPRECATED) || (PCMK_ALLOW_DEPRECATED == 1)
    pe_unknown      = pcmk_rsc_variant_unknown,
 
    pe_native       = pcmk_rsc_variant_primitive,
 
    pe_group        = pcmk_rsc_variant_group,
 
    pe_clone        = pcmk_rsc_variant_clone,
 
    pe_container    = pcmk_rsc_variant_bundle,
#endif
};
 
enum rsc_start_requirement {
    pcmk_requires_nothing   = 0,    
    pcmk_requires_quorum    = 1,    
    pcmk_requires_fencing   = 2,    
 
#if !defined(PCMK_ALLOW_DEPRECATED) || (PCMK_ALLOW_DEPRECATED == 1)
    rsc_req_nothing         = pcmk_requires_nothing,
 
    rsc_req_quorum          = pcmk_requires_quorum,
 
    rsc_req_stonith         = pcmk_requires_fencing,
#endif
};
 
enum rsc_recovery_type {
    pcmk_multiply_active_restart    = 0,    
    pcmk_multiply_active_stop       = 1,    
    pcmk_multiply_active_block      = 2,    
    pcmk_multiply_active_unexpected = 3,    
 
#if !defined(PCMK_ALLOW_DEPRECATED) || (PCMK_ALLOW_DEPRECATED == 1)
    recovery_stop_start             = pcmk_multiply_active_restart,
 
    recovery_stop_only              = pcmk_multiply_active_stop,
 
    recovery_block                  = pcmk_multiply_active_block,
 
    recovery_stop_unexpected        = pcmk_multiply_active_unexpected,
#endif
};
 
enum pcmk_rsc_flags {
    pcmk_no_rsc_flags               = 0ULL,
 
    pcmk_rsc_removed                = (1ULL << 0),
 
    pcmk_rsc_managed                = (1ULL << 1),
 
    pcmk_rsc_blocked                = (1ULL << 2),
 
    pcmk_rsc_removed_filler         = (1ULL << 3),
 
    pcmk_rsc_notify                 = (1ULL << 4),
 
    pcmk_rsc_unique                 = (1ULL << 5),
 
    pcmk_rsc_fence_device           = (1ULL << 6),
 
    pcmk_rsc_promotable             = (1ULL << 7),
 
    pcmk_rsc_unassigned             = (1ULL << 8),
 
    pcmk_rsc_assigning              = (1ULL << 9),
 
    pcmk_rsc_updating_nodes         = (1ULL << 10),
 
    pcmk_rsc_restarting             = (1ULL << 11),
 
    pcmk_rsc_stop_if_failed         = (1ULL << 12),
 
    pcmk_rsc_reload                 = (1ULL << 13),
 
    pcmk_rsc_remote_nesting_allowed = (1ULL << 14),
 
    pcmk_rsc_critical               = (1ULL << 15),
 
    pcmk_rsc_failed                 = (1ULL << 16),
 
    pcmk_rsc_detect_loop            = (1ULL << 17),
 
    pcmk_rsc_runnable               = (1ULL << 18),
 
    pcmk_rsc_start_pending          = (1ULL << 19),
 
    pcmk_rsc_starting               = (1ULL << 20),
 
    pcmk_rsc_stopping               = (1ULL << 21),
 
    pcmk_rsc_stop_unexpected        = (1ULL << 22),
 
    pcmk_rsc_migratable             = (1ULL << 23),
 
    pcmk_rsc_ignore_failure         = (1ULL << 24),
 
    pcmk_rsc_replica_container      = (1ULL << 25),
 
    pcmk_rsc_maintenance            = (1ULL << 26),
 
    pcmk_rsc_has_filler             = (1ULL << 27),
 
    pcmk_rsc_needs_quorum           = (1ULL << 28),
 
    pcmk_rsc_needs_fencing          = (1ULL << 29),
 
    pcmk_rsc_needs_unfencing        = (1ULL << 30),
};
 
enum pe_find {
    pcmk_rsc_match_history          = (1 << 0),
 
    pcmk_rsc_match_anon_basename    = (1 << 1),
 
    pcmk_rsc_match_clone_only       = (1 << 2),
 
    pcmk_rsc_match_current_node     = (1 << 3),
 
    pe_find_inactive                = (1 << 4),
 
    pcmk_rsc_match_basename         = (1 << 5),
 
#if !defined(PCMK_ALLOW_DEPRECATED) || (PCMK_ALLOW_DEPRECATED == 1)
    pe_find_renamed     = pcmk_rsc_match_history,
 
    pe_find_anon        = pcmk_rsc_match_anon_basename,
 
    pe_find_clone       = pcmk_rsc_match_clone_only,
 
    pe_find_current     = pcmk_rsc_match_current_node,
 
    pe_find_any         = pcmk_rsc_match_basename,
#endif
};
 
enum pe_restart {
    pe_restart_restart,
    pe_restart_ignore,
};
 
enum pe_print_options {
    pe_print_log            = (1 << 0),
    pe_print_html           = (1 << 1),
    pe_print_ncurses        = (1 << 2),
    pe_print_printf         = (1 << 3),
    pe_print_dev            = (1 << 4),  // Ignored
    pe_print_details        = (1 << 5),  // Ignored
    pe_print_max_details    = (1 << 6),  // Ignored
    pe_print_rsconly        = (1 << 7),
    pe_print_ops            = (1 << 8),
    pe_print_suppres_nl     = (1 << 9),
    pe_print_xml            = (1 << 10),
    pe_print_brief          = (1 << 11),
    pe_print_pending        = (1 << 12),
    pe_print_clone_details  = (1 << 13),
    pe_print_clone_active   = (1 << 14), // Print clone instances only if active
    pe_print_implicit       = (1 << 15)  // Print implicitly created resources
};
 
// Resource assignment methods (implementation defined by libpacemaker)
typedef struct resource_alloc_functions_s pcmk_assignment_methods_t;
 
typedef struct resource_object_functions_s {
    gboolean (*unpack)(pcmk_resource_t *rsc, pcmk_scheduler_t *scheduler);
 
    pcmk_resource_t *(*find_rsc)(pcmk_resource_t *rsc, const char *search,
                                 const pcmk_node_t *node, int flags);
 
    char *(*parameter)(pcmk_resource_t *rsc, pcmk_node_t *node, gboolean create,
                       const char *name, pcmk_scheduler_t *scheduler);
 
    void (*print)(pcmk_resource_t *rsc, const char *pre_text, long options,
                  void *print_data);
 
    gboolean (*active)(pcmk_resource_t *rsc, gboolean all);
 
    enum rsc_role_e (*state)(const pcmk_resource_t *rsc, gboolean current);
 
    pcmk_node_t *(*location)(const pcmk_resource_t *rsc, GList **list,
                             int current);
 
    void (*free)(pcmk_resource_t *rsc);
 
    void (*count)(pcmk_resource_t *rsc);
 
    gboolean (*is_filtered)(const pcmk_resource_t *rsc, GList *only_rsc,
                            gboolean check_parent);
 
    pcmk_node_t *(*active_node)(const pcmk_resource_t *rsc,
                                unsigned int *count_all,
                                unsigned int *count_clean);
 
    unsigned int (*max_per_node)(const pcmk_resource_t *rsc);
} pcmk_rsc_methods_t;
 
struct pe_resource_s {
    char *id;                           
    char *clone_name;                   
 
    xmlNode *xml;
 
    xmlNode *orig_xml;
 
    xmlNode *ops_xml;
 
    pcmk_scheduler_t *cluster;          
    pcmk_resource_t *parent;            
    enum pe_obj_types variant;          
    void *variant_opaque;               
    pcmk_rsc_methods_t *fns;            
    pcmk_assignment_methods_t *cmds;    
 
    enum rsc_recovery_type recovery_type;   
 
    enum pe_restart restart_type;   
    int priority;                   
    int stickiness;                 
    int sort_index;                 
    int failure_timeout;            
    int migration_threshold;        
    guint remote_reconnect_ms;      
    char *pending_task;             
    unsigned long long flags;       
 
    // @TODO Merge these into flags
    gboolean is_remote_node;        
    gboolean exclusive_discover;    
 
    /* Pay special attention to whether you want to use rsc_cons_lhs and
     * rsc_cons directly, which include only colocations explicitly involving
     * this resource, or call libpacemaker's pcmk__with_this_colocations() and
     * pcmk__this_with_colocations() functions, which may return relevant
     * colocations involving the resource's ancestors as well.
     */
 
    GList *rsc_cons_lhs;      // Colocations of other resources with this one
    GList *rsc_cons;          // Colocations of this resource with others
    GList *rsc_location;      // Location constraints for resource
    GList *actions;           // Actions scheduled for resource
    GList *rsc_tickets;       // Ticket constraints for resource
 
    pcmk_node_t *allocated_to;  
 
    pcmk_node_t *partial_migration_target;
 
    pcmk_node_t *partial_migration_source;
 
    GList *running_on;
 
    GHashTable *known_on;
 
    GHashTable *allowed_nodes;
 
    enum rsc_role_e role;           
    enum rsc_role_e next_role;      
 
    GHashTable *meta;               
    GHashTable *parameters;         
    GHashTable *utilization;        
 
    GList *children;                
 
    // Source nodes where stop is needed after migrate_from and migrate_to
    GList *dangling_migrations;
 
    pcmk_resource_t *container;     
    GList *fillers;                 
 
    // @COMPAT These should be made const at next API compatibility break
    pcmk_node_t *pending_node;      
    pcmk_node_t *lock_node;         
 
    time_t lock_time;               
 
    GHashTable *parameter_cache;
};
 
#ifdef __cplusplus
}
#endif
 
#endif // PCMK__CRM_COMMON_RESOURCES__H