No OneTemporary
Actions

Size

115 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/include/crm/pengine/pe_types.h b/include/crm/pengine/pe_types.h
	index a01ee3e9e5..de02dcb9af 100644
	--- a/include/crm/pengine/pe_types.h
	+++ b/include/crm/pengine/pe_types.h
	@@ -1,561 +1,568 @@
	/*
	* 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_PENGINE_PE_TYPES__H
	# define PCMK__CRM_PENGINE_PE_TYPES__H


	# include <stdbool.h> // bool
	# include <sys/types.h> // time_t
	# include <libxml/tree.h> // xmlNode
	# include <glib.h> // gboolean, guint, GList, GHashTable
	# include <crm/common/iso8601.h>
	# include <crm/pengine/common.h>

	#ifdef __cplusplus
	extern "C" {
	#endif

	/*!
	* \file
	* \brief Data types for cluster status
	* \ingroup pengine
	*/

	typedef struct pe_node_s pe_node_t;
	typedef struct pe_action_s pe_action_t;
	typedef struct pe_resource_s pe_resource_t;
	typedef struct pe_working_set_s pe_working_set_t;

	enum pe_obj_types {
	pe_unknown = -1,
	pe_native = 0,
	pe_group = 1,
	pe_clone = 2,
	pe_container = 3,
	};

	typedef struct resource_object_functions_s {
	gboolean (unpack) (pe_resource_t, pe_working_set_t*);
	pe_resource_t (find_rsc) (pe_resource_t parent, const char search,
	const pe_node_t *node, int flags);
	/* parameter result must be free'd */
	char (parameter) (pe_resource_t, pe_node_t, gboolean, const char*,
	pe_working_set_t*);
	//! \deprecated will be removed in a future release
	void (print) (pe_resource_t, const char, long, void);
	gboolean (active) (pe_resource_t, gboolean);
	enum rsc_role_e (state) (const pe_resource_t, gboolean);
	pe_node_t (location) (const pe_resource_t, GList*, int);
	void (free) (pe_resource_t);
	void (count) (pe_resource_t);
	gboolean (is_filtered) (const pe_resource_t, GList *, gboolean);

	/*!
	* \brief
	* \internal Find a node (and optionally count all) where resource is active
	*
	* \param[in] rsc Resource to check
	* \param[out] count_all If not NULL, set this to count of active nodes
	* \param[out] count_clean If not NULL, set this to count of clean nodes
	*
	* \return A node where the resource is active, preferring the source node
	* if the resource is involved in a partial migration or a clean,
	* online node if the resource's "requires" is "quorum" or
	* "nothing", or NULL if the resource is inactive.
	*/
	pe_node_t (active_node)(const pe_resource_t rsc, unsigned int count_all,
	unsigned int *count_clean);
	} resource_object_functions_t;

	typedef struct resource_alloc_functions_s resource_alloc_functions_t;

	enum pe_quorum_policy {
	no_quorum_freeze,
	no_quorum_stop,
	no_quorum_ignore,
	no_quorum_suicide,
	no_quorum_demote
	};

	enum node_type {
	node_ping, //! \deprecated Do not use
	node_member,
	node_remote
	};

	//! \deprecated will be removed in a future release
	enum pe_restart {
	pe_restart_restart, //! \deprecated will be removed in a future release
	pe_restart_ignore //! \deprecated will be removed in a future release
	};

	//! Determine behavior of pe_find_resource_with_flags()
	enum pe_find {
	pe_find_renamed = 0x001, //!< match resource ID or LRM history ID
	pe_find_anon = 0x002, //!< match base name of anonymous clone instances
	pe_find_clone = 0x004, //!< match only clone instances
	pe_find_current = 0x008, //!< match resource active on specified node
	pe_find_inactive = 0x010, //!< match resource not running anywhere
	pe_find_any = 0x020, //!< match base name of any clone instance
	};

	// @TODO Make these an enum

	# define pe_flag_have_quorum 0x00000001ULL
	# define pe_flag_symmetric_cluster 0x00000002ULL
	# define pe_flag_maintenance_mode 0x00000008ULL

	# define pe_flag_stonith_enabled 0x00000010ULL
	# define pe_flag_have_stonith_resource 0x00000020ULL
	# define pe_flag_enable_unfencing 0x00000040ULL
	# define pe_flag_concurrent_fencing 0x00000080ULL

	# define pe_flag_stop_rsc_orphans 0x00000100ULL
	# define pe_flag_stop_action_orphans 0x00000200ULL
	# define pe_flag_stop_everything 0x00000400ULL

	# define pe_flag_start_failure_fatal 0x00001000ULL

	//! \deprecated
	# define pe_flag_remove_after_stop 0x00002000ULL

	# define pe_flag_startup_fencing 0x00004000ULL
	# define pe_flag_shutdown_lock 0x00008000ULL

	# define pe_flag_startup_probes 0x00010000ULL
	# define pe_flag_have_status 0x00020000ULL
	# define pe_flag_have_remote_nodes 0x00040000ULL

	# define pe_flag_quick_location 0x00100000ULL
	# define pe_flag_sanitized 0x00200000ULL

	//! \deprecated
	# define pe_flag_stdout 0x00400000ULL

	//! Don't count total, disabled and blocked resource instances
	# define pe_flag_no_counts 0x00800000ULL

	/*! Skip deprecated code that is kept solely for backward API compatibility.
	* (Internal code should always set this.)
	*/
	# define pe_flag_no_compat 0x01000000ULL

	# define pe_flag_show_scores 0x02000000ULL
	# define pe_flag_show_utilization 0x04000000ULL

	/*!
	* When scheduling, only unpack the CIB (including constraints), calculate
	* as much cluster status as possible, and apply node health.
	*/
	# define pe_flag_check_config 0x08000000ULL

	struct pe_working_set_s {
	xmlNode *input;
	crm_time_t *now;

	/* options extracted from the input */
	char *dc_uuid;
	pe_node_t *dc_node;
	const char *stonith_action;
	const char *placement_strategy;

	unsigned long long flags;

	int stonith_timeout;
	enum pe_quorum_policy no_quorum_policy;

	GHashTable *config_hash;
	GHashTable *tickets;

	// Actions for which there can be only one (e.g. fence nodeX)
	GHashTable *singletons;

	GList *nodes;
	GList *resources;
	GList *placement_constraints;
	GList *ordering_constraints;
	GList *colocation_constraints;
	GList *ticket_constraints;

	GList *actions;
	xmlNode *failed;
	xmlNode *op_defaults;
	xmlNode *rsc_defaults;

	/* stats */
	int num_synapse;
	int max_valid_nodes; //! Deprecated (will be removed in a future release)
	int order_id;
	int action_id;

	/* final output */
	xmlNode *graph;

	GHashTable *template_rsc_sets;
	const char *localhost;
	GHashTable *tags;

	int blocked_resources;
	int disabled_resources;

	GList *param_check; // History entries that need to be checked
	GList *stop_needed; // Containers that need stop actions
	time_t recheck_by; // Hint to controller to re-run scheduler by this time
	int ninstances; // Total number of resource instances
	guint shutdown_lock;// How long (seconds) to lock resources to shutdown node
	int priority_fencing_delay; // Priority fencing delay

	void *priv;
	};

	enum pe_check_parameters {
	/* Clear fail count if parameters changed for un-expired start or monitor
	* last_failure.
	*/
	pe_check_last_failure,

	/* Clear fail count if parameters changed for start, monitor, promote, or
	* migrate_from actions for active resources.
	*/
	pe_check_active,
	};

	struct pe_node_shared_s {
	const char *id;
	const char *uname;
	enum node_type type;

	/* @TODO convert these flags into a bitfield */
	gboolean online;
	gboolean standby;
	gboolean standby_onfail;
	gboolean pending;
	gboolean unclean;
	gboolean unseen;
	gboolean shutdown;
	gboolean expected_up;
	gboolean is_dc;
	gboolean maintenance;
	gboolean rsc_discovery_enabled;
	gboolean remote_requires_reset;
	gboolean remote_was_fenced;
	gboolean remote_maintenance; /* what the remote-rsc is thinking */
	gboolean unpacked;

	int num_resources;
	pe_resource_t *remote_rsc;
	GList running_rsc; / pe_resource_t* */
	GList allocated_rsc; / pe_resource_t* */

	GHashTable attrs; / char* => char* */
	GHashTable *utilization;
	GHashTable *digest_cache; //!< cache of calculated resource digests
	int priority; // calculated based on the priority of resources running on the node
	pe_working_set_t *data_set; //!< Cluster that this node is part of
	};

	struct pe_node_s {
	int weight;
	gboolean fixed; //!< \deprecated Will be removed in a future release
	int count;
	struct pe_node_shared_s *details;
	int rsc_discover_mode;
	};

	# define pe_rsc_orphan 0x00000001ULL
	# define pe_rsc_managed 0x00000002ULL
	# define pe_rsc_block 0x00000004ULL
	# define pe_rsc_orphan_container_filler 0x00000008ULL

	# define pe_rsc_notify 0x00000010ULL
	# define pe_rsc_unique 0x00000020ULL
	# define pe_rsc_fence_device 0x00000040ULL
	# define pe_rsc_promotable 0x00000080ULL

	# define pe_rsc_provisional 0x00000100ULL
	# define pe_rsc_allocating 0x00000200ULL
	# define pe_rsc_merging 0x00000400ULL
	# define pe_rsc_restarting 0x00000800ULL

	# define pe_rsc_stop 0x00001000ULL
	# define pe_rsc_reload 0x00002000ULL
	# define pe_rsc_allow_remote_remotes 0x00004000ULL
	# define pe_rsc_critical 0x00008000ULL

	# define pe_rsc_failed 0x00010000ULL
	# define pe_rsc_detect_loop 0x00020000ULL
	# define pe_rsc_runnable 0x00040000ULL
	# define pe_rsc_start_pending 0x00080000ULL

	//!< \deprecated Do not use
	# define pe_rsc_starting 0x00100000ULL

	//!< \deprecated Do not use
	# define pe_rsc_stopping 0x00200000ULL

	# define pe_rsc_stop_unexpected 0x00400000ULL
	# define pe_rsc_allow_migrate 0x00800000ULL

	# define pe_rsc_failure_ignored 0x01000000ULL
	# define pe_rsc_replica_container 0x02000000ULL
	# define pe_rsc_maintenance 0x04000000ULL
	# define pe_rsc_is_container 0x08000000ULL

	# define pe_rsc_needs_quorum 0x10000000ULL
	# define pe_rsc_needs_fencing 0x20000000ULL
	# define pe_rsc_needs_unfencing 0x40000000ULL

	/* INDENT-OFF */
	enum pe_action_flags {
	pe_action_pseudo = 0x00001,
	pe_action_runnable = 0x00002,
	pe_action_optional = 0x00004,
	pe_action_print_always = 0x00008,

	pe_action_have_node_attrs = 0x00010,
	pe_action_implied_by_stonith = 0x00040,
	pe_action_migrate_runnable = 0x00080,

	pe_action_dumped = 0x00100,
	pe_action_processed = 0x00200,
	#if !defined(PCMK_ALLOW_DEPRECATED) \|\| (PCMK_ALLOW_DEPRECATED == 1)
	pe_action_clear = 0x00400, //! \deprecated Unused
	#endif
	pe_action_dangle = 0x00800,

	/* This action requires one or more of its dependencies to be runnable.
	* We use this to clear the runnable flag before checking dependencies.
	*/
	pe_action_requires_any = 0x01000,

	pe_action_reschedule = 0x02000,
	pe_action_tracking = 0x04000,
	pe_action_dedup = 0x08000, //! Internal state tracking when creating graph

	pe_action_dc = 0x10000, //! Action may run on DC instead of target
	};
	/* INDENT-ON */

	struct pe_resource_s {
	char *id;
	char *clone_name;
	xmlNode *xml;
	xmlNode *orig_xml;
	xmlNode *ops_xml;

	pe_working_set_t *cluster;
	pe_resource_t *parent;

	enum pe_obj_types variant;
	void *variant_opaque;
	resource_object_functions_t *fns;
	resource_alloc_functions_t *cmds;

	enum rsc_recovery_type recovery_type;

	enum pe_restart restart_type; //!< \deprecated will be removed in future release

	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 the pcmk__with_this_colocations() and
	+ * pcmk__this_with_colocations() functions, which may return relevant
	+ * colocations involving the resource's parents as well.
	+ */
	+
	//!@{
	//! This field should be treated as internal to Pacemaker
	GList rsc_cons_lhs; // List of pcmk__colocation_t
	GList rsc_cons; // List of pcmk__colocation_t
	GList rsc_location; // List of pe__location_t
	GList actions; // List of pe_action_t
	GList rsc_tickets; // List of rsc_ticket
	//!@}

	pe_node_t *allocated_to;
	pe_node_t *partial_migration_target;
	pe_node_t *partial_migration_source;
	GList running_on; / pe_node_t* */
	GHashTable known_on; / pe_node_t* */
	GHashTable allowed_nodes; / pe_node_t* */

	enum rsc_role_e role;
	enum rsc_role_e next_role;

	GHashTable *meta;
	GHashTable *parameters; //! \deprecated Use pe_rsc_params() instead
	GHashTable *utilization;

	GList children; / pe_resource_t* */
	GList dangling_migrations; / pe_node_t* */

	pe_resource_t *container;
	GList *fillers;

	// @COMPAT These should be made const at next API compatibility break
	pe_node_t *pending_node; // Node on which pending_task is happening
	pe_node_t *lock_node; // Resource is shutdown-locked to this node

	time_t lock_time; // When shutdown lock started

	/* Resource parameters may have node-attribute-based rules, which means the
	* values can vary by node. This table is a cache of parameter name/value
	* tables for each node (as needed). Use pe_rsc_params() to get the table
	* for a given node.
	*/
	GHashTable *parameter_cache; // Key = node name, value = parameters table
	};

	struct pe_action_s {
	int id;
	int priority;

	pe_resource_t *rsc;
	pe_node_t *node;
	xmlNode *op_entry;

	char *task;
	char *uuid;
	char *cancel_task;
	char *reason;

	enum pe_action_flags flags;
	enum rsc_start_requirement needs;
	enum action_fail_response on_fail;
	enum rsc_role_e fail_role;

	GHashTable *meta;
	GHashTable *extra;

	/*
	* These two varables are associated with the constraint logic
	* that involves first having one or more actions runnable before
	* then allowing this action to execute.
	*
	* These varables are used with features such as 'clone-min' which
	* requires at minimum X number of cloned instances to be running
	* before an order dependency can run. Another option that uses
	* this is 'require-all=false' in ordering constrants. This option
	* says "only require one instance of a resource to start before
	* allowing dependencies to start" -- basically, require-all=false is
	* the same as clone-min=1.
	*/

	/* current number of known runnable actions in the before list. */
	int runnable_before;
	/* the number of "before" runnable actions required for this action
	* to be considered runnable */
	int required_runnable_before;

	GList actions_before; / pe_action_wrapper_t* */
	GList actions_after; / pe_action_wrapper_t* */

	/* Some of the above fields could be moved to the details,
	* except for API backward compatibility.
	*/
	void *action_details; // varies by type of action
	};

	typedef struct pe_ticket_s {
	char *id;
	gboolean granted;
	time_t last_granted;
	gboolean standby;
	GHashTable *state;
	} pe_ticket_t;

	typedef struct pe_tag_s {
	char *id;
	GList *refs;
	} pe_tag_t;

	//! Internal tracking for transition graph creation
	enum pe_link_state {
	pe_link_not_dumped, //! Internal tracking for transition graph creation
	pe_link_dumped, //! Internal tracking for transition graph creation
	pe_link_dup, //! \deprecated No longer used by Pacemaker
	};

	enum pe_discover_e {
	pe_discover_always = 0,
	pe_discover_never,
	pe_discover_exclusive,
	};

	/* INDENT-OFF */
	enum pe_ordering {
	pe_order_none = 0x0, /* deleted */
	pe_order_optional = 0x1, /* pure ordering, nothing implied */
	pe_order_apply_first_non_migratable = 0x2, /* Only apply this constraint's ordering if first is not migratable. */

	pe_order_implies_first = 0x10, /* If 'then' is required, ensure 'first' is too */
	pe_order_implies_then = 0x20, /* If 'first' is required, ensure 'then' is too */
	pe_order_promoted_implies_first = 0x40, /* If 'then' is required and then's rsc is promoted, ensure 'first' becomes required too */

	/* first requires then to be both runnable and migrate runnable. */
	pe_order_implies_first_migratable = 0x80,

	pe_order_runnable_left = 0x100, /* 'then' requires 'first' to be runnable */

	pe_order_pseudo_left = 0x200, /* 'then' can only be pseudo if 'first' is runnable */
	pe_order_implies_then_on_node = 0x400, /* If 'first' is required on 'nodeX',
	* ensure instances of 'then' on 'nodeX' are too.
	* Only really useful if 'then' is a clone and 'first' is not
	*/
	pe_order_probe = 0x800, /* If 'first->rsc' is
	* - running but about to stop, ignore the constraint
	* - otherwise, behave as runnable_left
	*/

	pe_order_restart = 0x1000, /* 'then' is runnable if 'first' is optional or runnable */
	pe_order_stonith_stop = 0x2000, //<! \deprecated Will be removed in future release
	pe_order_serialize_only = 0x4000, /* serialize */
	pe_order_same_node = 0x8000, /* applies only if 'first' and 'then' are on same node */

	pe_order_implies_first_printed = 0x10000, /* Like ..implies_first but only ensures 'first' is printed, not mandatory */
	pe_order_implies_then_printed = 0x20000, /* Like ..implies_then but only ensures 'then' is printed, not mandatory */

	pe_order_asymmetrical = 0x100000, /* Indicates asymmetrical one way ordering constraint. */
	pe_order_load = 0x200000, /* Only relevant if... */
	pe_order_one_or_more = 0x400000, /* 'then' is runnable only if one or more of its dependencies are too */
	pe_order_anti_colocation = 0x800000,

	pe_order_preserve = 0x1000000, /* Hack for breaking user ordering constraints with container resources */
	pe_order_then_cancels_first = 0x2000000, // if 'then' becomes required, 'first' becomes optional
	pe_order_trace = 0x4000000, /* test marker */

	#if !defined(PCMK_ALLOW_DEPRECATED) \|\| (PCMK_ALLOW_DEPRECATED == 1)
	// \deprecated Use pe_order_promoted_implies_first instead
	pe_order_implies_first_master = pe_order_promoted_implies_first,
	#endif
	};
	/* INDENT-ON */

	typedef struct pe_action_wrapper_s {
	enum pe_ordering type;
	enum pe_link_state state;
	pe_action_t *action;
	} pe_action_wrapper_t;

	#if !defined(PCMK_ALLOW_DEPRECATED) \|\| (PCMK_ALLOW_DEPRECATED == 1)
	#include <crm/pengine/pe_types_compat.h>
	#endif

	#ifdef __cplusplus
	}
	#endif

	#endif // PCMK__CRM_PENGINE_PE_TYPES__H
	diff --git a/include/pcmki/pcmki_scheduler.h b/include/pcmki/pcmki_scheduler.h
	index e721c3583a..dde50a57e3 100644
	--- a/include/pcmki/pcmki_scheduler.h
	+++ b/include/pcmki/pcmki_scheduler.h
	@@ -1,40 +1,43 @@
	/*
	- * Copyright 2014-2022 the Pacemaker project contributors
	+ * Copyright 2014-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__PCMKI_PCMKI_SCHEDULER__H
	# define PCMK__PCMKI_PCMKI_SCHEDULER__H

	# include <glib.h>
	# include <crm/crm.h>
	# include <crm/common/iso8601.h>
	# include <crm/pengine/rules.h>
	# include <crm/pengine/common.h>
	# include <crm/pengine/status.h>

	# include <crm/pengine/complex.h>

	typedef struct {
	const char *id;
	const char *node_attribute;
	pe_resource_t *dependent; // The resource being colocated
	pe_resource_t *primary; // The resource the dependent is colocated with

	int dependent_role; // Colocation applies only if dependent has this role
	int primary_role; // Colocation applies only if primary has this role

	int score;
	bool influence; // Whether dependent influences active primary placement
	} pcmk__colocation_t;

	void pcmk__unpack_constraints(pe_working_set_t *data_set);

	void pcmk__schedule_actions(xmlNode *cib, unsigned long long flags,
	pe_working_set_t *data_set);

	+GList pcmk__with_this_colocations(const pe_resource_t rsc);
	+GList pcmk__this_with_colocations(const pe_resource_t rsc);
	+
	#endif
	diff --git a/lib/pacemaker/libpacemaker_private.h b/lib/pacemaker/libpacemaker_private.h
	index 30eeb0fdba..e9604d0bdc 100644
	--- a/lib/pacemaker/libpacemaker_private.h
	+++ b/lib/pacemaker/libpacemaker_private.h
	@@ -1,941 +1,945 @@
	/*
	* Copyright 2021-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__LIBPACEMAKER_PRIVATE__H
	# define PCMK__LIBPACEMAKER_PRIVATE__H

	/* This header is for the sole use of libpacemaker, so that functions can be
	* declared with G_GNUC_INTERNAL for efficiency.
	*/

	#include <crm/pengine/pe_types.h> // pe_action_t, pe_node_t, pe_working_set_t

	// Flags to modify the behavior of pcmk__add_colocated_node_scores()
	enum pcmk__coloc_select {
	// With no other flags, apply all "with this" colocations
	pcmk__coloc_select_default = 0,

	// Apply "this with" colocations instead of "with this" colocations
	pcmk__coloc_select_this_with = (1 << 0),

	// Apply only colocations with non-negative scores
	pcmk__coloc_select_nonnegative = (1 << 1),

	// Apply only colocations with at least one matching node
	pcmk__coloc_select_active = (1 << 2),
	};

	// Flags the update_ordered_actions() method can return
	enum pcmk__updated {
	pcmk__updated_none = 0, // Nothing changed
	pcmk__updated_first = (1 << 0), // First action was updated
	pcmk__updated_then = (1 << 1), // Then action was updated
	};

	#define pcmk__set_updated_flags(au_flags, action, flags_to_set) do { \
	au_flags = pcmk__set_flags_as(__func__, __LINE__, \
	LOG_TRACE, "Action update", \
	(action)->uuid, au_flags, \
	(flags_to_set), #flags_to_set); \
	} while (0)

	#define pcmk__clear_updated_flags(au_flags, action, flags_to_clear) do { \
	au_flags = pcmk__clear_flags_as(__func__, __LINE__, \
	LOG_TRACE, "Action update", \
	(action)->uuid, au_flags, \
	(flags_to_clear), #flags_to_clear); \
	} while (0)

	// Resource allocation methods
	struct resource_alloc_functions_s {
	/*!
	* \internal
	* \brief Assign a resource to a node
	*
	* \param[in,out] rsc Resource to assign to a node
	* \param[in] prefer Node to prefer, if all else is equal
	*
	* \return Node that \p rsc is assigned to, if assigned entirely to one node
	*/
	pe_node_t (assign)(pe_resource_t rsc, const pe_node_t prefer);

	/*!
	* \internal
	* \brief Create all actions needed for a given resource
	*
	* \param[in,out] rsc Resource to create actions for
	*/
	void (create_actions)(pe_resource_t rsc);

	/*!
	* \internal
	* \brief Schedule any probes needed for a resource on a node
	*
	* \param[in,out] rsc Resource to create probe for
	* \param[in,out] node Node to create probe on
	*
	* \return true if any probe was created, otherwise false
	*/
	bool (create_probe)(pe_resource_t rsc, pe_node_t *node);

	/*!
	* \internal
	* \brief Create implicit constraints needed for a resource
	*
	* \param[in,out] rsc Resource to create implicit constraints for
	*/
	void (internal_constraints)(pe_resource_t rsc);

	/*!
	* \internal
	* \brief Apply a colocation's score to node weights or resource priority
	*
	* Given a colocation constraint, apply its score to the dependent's
	* allowed node weights (if we are still placing resources) or priority (if
	* we are choosing promotable clone instance roles).
	*
	* \param[in,out] dependent Dependent resource in colocation
	* \param[in] primary Primary resource in colocation
	* \param[in] colocation Colocation constraint to apply
	* \param[in] for_dependent true if called on behalf of dependent
	*/
	void (apply_coloc_score) (pe_resource_t dependent,
	const pe_resource_t *primary,
	const pcmk__colocation_t *colocation,
	bool for_dependent);

	/*!
	* \internal
	* \brief Create list of all resources in colocations with a given resource
	*
	* Given a resource, create a list of all resources involved in mandatory
	* colocations with it, whether directly or indirectly via chained colocations.
	*
	* \param[in] rsc Resource to add to colocated list
	* \param[in] orig_rsc Resource originally requested
	* \param[in,out] colocated_rscs Existing list
	*
	* \return List of given resource and all resources involved in colocations
	*
	* \note This function is recursive; top-level callers should pass NULL as
	* \p colocated_rscs and \p orig_rsc, and the desired resource as
	* \p rsc. The recursive calls will use other values.
	*/
	GList (colocated_resources)(const pe_resource_t *rsc,
	const pe_resource_t *orig_rsc,
	GList *colocated_rscs);

	/*!
	* \internal
	* \brief Add colocations affecting a resource as primary to a list
	*
	* \param[in] rsc Resource whose colocations should be added
	* \param[in] orig_rsc Affected resource (\p rsc or a descendent)
	* \param[in,out] list List of colocations to add to
	*
	* \note All arguments should be non-NULL.
	+ * \note The pcmk__with_this_colocations() wrapper should usually be used
	+ * instead of using this method directly.
	*/
	void (with_this_colocations)(const pe_resource_t rsc,
	const pe_resource_t orig_rsc, GList *list);

	/*!
	* \internal
	* \brief Add colocations affecting a resource as dependent to a list
	*
	* \param[in] rsc Resource whose colocations should be added
	* \param[in] orig_rsc Affected resource (\p rsc or a descendent)
	* \param[in,out] list List of colocations to add to
	*
	* \note All arguments should be non-NULL.
	+ * \note The pcmk__this_with_colocations() wrapper should usually be used
	+ * instead of using this method directly.
	*/
	void (this_with_colocations)(const pe_resource_t rsc,
	const pe_resource_t orig_rsc, GList *list);

	/*!
	* \internal
	* \brief Apply a location constraint to a resource's allowed node scores
	*
	* \param[in,out] rsc Resource to apply constraint to
	* \param[in,out] location Location constraint to apply
	*/
	void (apply_location)(pe_resource_t rsc, pe__location_t *location);

	/*!
	* \internal
	* \brief Return action flags for a given resource action
	*
	* \param[in,out] action Action to get flags for
	* \param[in] node If not NULL, limit effects to this node
	*
	* \return Flags appropriate to \p action on \p node
	* \note For primitives, this will be the same as action->flags regardless
	* of node. For collective resources, the flags can differ due to
	* multiple instances possibly being involved.
	*/
	enum pe_action_flags (action_flags)(pe_action_t action,
	const pe_node_t *node);

	/*!
	* \internal
	* \brief Update two actions according to an ordering between them
	*
	* Given information about an ordering of two actions, update the actions'
	* flags (and runnable_before members if appropriate) as appropriate for the
	* ordering. Effects may cascade to other orderings involving the actions as
	* well.
	*
	* \param[in,out] first 'First' action in an ordering
	* \param[in,out] then 'Then' action in an ordering
	* \param[in] node If not NULL, limit scope of ordering to this
	* node (only used when interleaving instances)
	* \param[in] flags Action flags for \p first for ordering purposes
	* \param[in] filter Action flags to limit scope of certain updates
	* (may include pe_action_optional to affect only
	* mandatory actions, and pe_action_runnable to
	* affect only runnable actions)
	* \param[in] type Group of enum pe_ordering flags to apply
	* \param[in,out] data_set Cluster working set
	*
	* \return Group of enum pcmk__updated flags indicating what was updated
	*/
	uint32_t (update_ordered_actions)(pe_action_t first, pe_action_t *then,
	const pe_node_t *node, uint32_t flags,
	uint32_t filter, uint32_t type,
	pe_working_set_t *data_set);

	void (output_actions)(pe_resource_t rsc);

	/*!
	* \internal
	* \brief Add a resource's actions to the transition graph
	*
	* \param[in,out] rsc Resource whose actions should be added
	*/
	void (add_actions_to_graph)(pe_resource_t rsc);

	/*!
	* \internal
	* \brief Add meta-attributes relevant to transition graph actions to XML
	*
	* If a given resource supports variant-specific meta-attributes that are
	* needed for transition graph actions, add them to a given XML element.
	*
	* \param[in] rsc Resource whose meta-attributes should be added
	* \param[in,out] xml Transition graph action attributes XML to add to
	*/
	void (add_graph_meta)(const pe_resource_t rsc, xmlNode *xml);

	/*!
	* \internal
	* \brief Add a resource's utilization to a table of utilization values
	*
	* This function is used when summing the utilization of a resource and all
	* resources colocated with it, to determine whether a node has sufficient
	* capacity. Given a resource and a table of utilization values, it will add
	* the resource's utilization to the existing values, if the resource has
	* not yet been allocated to a node.
	*
	* \param[in] rsc Resource with utilization to add
	* \param[in] orig_rsc Resource being allocated (for logging only)
	* \param[in] all_rscs List of all resources that will be summed
	* \param[in,out] utilization Table of utilization values to add to
	*/
	void (add_utilization)(const pe_resource_t rsc,
	const pe_resource_t orig_rsc, GList all_rscs,
	GHashTable *utilization);

	/*!
	* \internal
	* \brief Apply a shutdown lock for a resource, if appropriate
	*
	* \param[in,out] rsc Resource to check for shutdown lock
	*/
	void (shutdown_lock)(pe_resource_t rsc);
	};

	// Actions (pcmk_sched_actions.c)

	G_GNUC_INTERNAL
	void pcmk__update_action_for_orderings(pe_action_t *action,
	pe_working_set_t *data_set);

	G_GNUC_INTERNAL
	uint32_t pcmk__update_ordered_actions(pe_action_t first, pe_action_t then,
	const pe_node_t *node, uint32_t flags,
	uint32_t filter, uint32_t type,
	pe_working_set_t *data_set);

	G_GNUC_INTERNAL
	void pcmk__log_action(const char pre_text, const pe_action_t action,
	bool details);

	G_GNUC_INTERNAL
	pe_action_t pcmk__new_cancel_action(pe_resource_t rsc, const char *name,
	guint interval_ms, const pe_node_t *node);

	G_GNUC_INTERNAL
	pe_action_t pcmk__new_shutdown_action(pe_node_t node);

	G_GNUC_INTERNAL
	bool pcmk__action_locks_rsc_to_node(const pe_action_t *action);

	G_GNUC_INTERNAL
	void pcmk__deduplicate_action_inputs(pe_action_t *action);

	G_GNUC_INTERNAL
	void pcmk__output_actions(pe_working_set_t *data_set);

	G_GNUC_INTERNAL
	bool pcmk__check_action_config(pe_resource_t rsc, pe_node_t node,
	const xmlNode *xml_op);

	G_GNUC_INTERNAL
	void pcmk__handle_rsc_config_changes(pe_working_set_t *data_set);


	// Recurring actions (pcmk_sched_recurring.c)

	G_GNUC_INTERNAL
	void pcmk__create_recurring_actions(pe_resource_t *rsc);

	G_GNUC_INTERNAL
	void pcmk__schedule_cancel(pe_resource_t rsc, const char call_id,
	const char *task, guint interval_ms,
	const pe_node_t node, const char reason);

	G_GNUC_INTERNAL
	void pcmk__reschedule_recurring(pe_resource_t rsc, const char task,
	guint interval_ms, pe_node_t *node);

	G_GNUC_INTERNAL
	bool pcmk__action_is_recurring(const pe_action_t *action);


	// Producing transition graphs (pcmk_graph_producer.c)

	G_GNUC_INTERNAL
	bool pcmk__graph_has_loop(const pe_action_t *init_action,
	const pe_action_t *action,
	pe_action_wrapper_t *input);

	G_GNUC_INTERNAL
	void pcmk__add_rsc_actions_to_graph(pe_resource_t *rsc);

	G_GNUC_INTERNAL
	void pcmk__create_graph(pe_working_set_t *data_set);


	// Fencing (pcmk_sched_fencing.c)

	G_GNUC_INTERNAL
	void pcmk__order_vs_fence(pe_action_t stonith_op, pe_working_set_t data_set);

	G_GNUC_INTERNAL
	void pcmk__order_vs_unfence(const pe_resource_t rsc, pe_node_t node,
	pe_action_t *action, enum pe_ordering order);

	G_GNUC_INTERNAL
	void pcmk__fence_guest(pe_node_t *node);

	G_GNUC_INTERNAL
	bool pcmk__node_unfenced(const pe_node_t *node);

	G_GNUC_INTERNAL
	void pcmk__order_restart_vs_unfence(gpointer data, gpointer user_data);


	// Injected scheduler inputs (pcmk_sched_injections.c)

	void pcmk__inject_scheduler_input(pe_working_set_t data_set, cib_t cib,
	const pcmk_injections_t *injections);


	// Constraints of any type (pcmk_sched_constraints.c)

	G_GNUC_INTERNAL
	pe_resource_t pcmk__find_constraint_resource(GList rsc_list, const char *id);

	G_GNUC_INTERNAL
	xmlNode pcmk__expand_tags_in_sets(xmlNode xml_obj,
	const pe_working_set_t *data_set);

	G_GNUC_INTERNAL
	bool pcmk__valid_resource_or_tag(const pe_working_set_t *data_set,
	const char id, pe_resource_t *rsc,
	pe_tag_t **tag);

	G_GNUC_INTERNAL
	bool pcmk__tag_to_set(xmlNode xml_obj, xmlNode rsc_set, const char attr,
	bool convert_rsc, const pe_working_set_t *data_set);

	G_GNUC_INTERNAL
	void pcmk__create_internal_constraints(pe_working_set_t *data_set);


	// Location constraints

	G_GNUC_INTERNAL
	void pcmk__unpack_location(xmlNode xml_obj, pe_working_set_t data_set);

	G_GNUC_INTERNAL
	pe__location_t pcmk__new_location(const char id, pe_resource_t *rsc,
	int node_weight, const char *discover_mode,
	pe_node_t *foo_node,
	pe_working_set_t *data_set);

	G_GNUC_INTERNAL
	void pcmk__apply_locations(pe_working_set_t *data_set);

	G_GNUC_INTERNAL
	void pcmk__apply_location(pe_resource_t rsc, pe__location_t constraint);


	// Colocation constraints (pcmk_sched_colocation.c)

	enum pcmk__coloc_affects {
	pcmk__coloc_affects_nothing = 0,
	pcmk__coloc_affects_location,
	pcmk__coloc_affects_role,
	};

	G_GNUC_INTERNAL
	enum pcmk__coloc_affects pcmk__colocation_affects(const pe_resource_t *dependent,
	const pe_resource_t *primary,
	const pcmk__colocation_t *colocation,
	bool preview);

	G_GNUC_INTERNAL
	void pcmk__apply_coloc_to_weights(pe_resource_t *dependent,
	const pe_resource_t *primary,
	const pcmk__colocation_t *colocation);

	G_GNUC_INTERNAL
	void pcmk__apply_coloc_to_priority(pe_resource_t *dependent,
	const pe_resource_t *primary,
	const pcmk__colocation_t *colocation);

	G_GNUC_INTERNAL
	void pcmk__add_colocated_node_scores(pe_resource_t rsc, const char log_id,
	GHashTable *nodes, const char attr,
	float factor, uint32_t flags);

	G_GNUC_INTERNAL
	void pcmk__unpack_colocation(xmlNode xml_obj, pe_working_set_t data_set);

	G_GNUC_INTERNAL
	void pcmk__add_this_with(GList *list, const pcmk__colocation_t colocation);

	G_GNUC_INTERNAL
	void pcmk__add_this_with_list(GList *list, GList addition);

	G_GNUC_INTERNAL
	void pcmk__add_with_this(GList *list, const pcmk__colocation_t colocation);

	G_GNUC_INTERNAL
	void pcmk__add_with_this_list(GList *list, GList addition);

	G_GNUC_INTERNAL
	void pcmk__new_colocation(const char id, const char node_attr, int score,
	pe_resource_t dependent, pe_resource_t primary,
	const char dependent_role, const char primary_role,
	bool influence, pe_working_set_t *data_set);

	G_GNUC_INTERNAL
	void pcmk__block_colocation_dependents(pe_action_t *action,
	pe_working_set_t *data_set);

	/*!
	* \internal
	* \brief Check whether colocation's dependent preferences should be considered
	*
	* \param[in] colocation Colocation constraint
	* \param[in] rsc Primary instance (normally this will be
	* colocation->primary, which NULL will be treated as,
	* but for clones or bundles with multiple instances
	* this can be a particular instance)
	*
	* \return true if colocation influence should be effective, otherwise false
	*/
	static inline bool
	pcmk__colocation_has_influence(const pcmk__colocation_t *colocation,
	const pe_resource_t *rsc)
	{
	if (rsc == NULL) {
	rsc = colocation->primary;
	}

	/* A bundle replica colocates its remote connection with its container,
	* using a finite score so that the container can run on Pacemaker Remote
	* nodes.
	*
	* Moving a connection is lightweight and does not interrupt the service,
	* while moving a container is heavyweight and does interrupt the service,
	* so don't move a clean, active container based solely on the preferences
	* of its connection.
	*
	* This also avoids problematic scenarios where two containers want to
	* perpetually swap places.
	*/
	if (pcmk_is_set(colocation->dependent->flags, pe_rsc_allow_remote_remotes)
	&& !pcmk_is_set(rsc->flags, pe_rsc_failed)
	&& pcmk__list_of_1(rsc->running_on)) {
	return false;
	}

	/* The dependent in a colocation influences the primary's location
	* if the influence option is true or the primary is not yet active.
	*/
	return colocation->influence \|\| (rsc->running_on == NULL);
	}


	// Ordering constraints (pcmk_sched_ordering.c)

	G_GNUC_INTERNAL
	void pcmk__new_ordering(pe_resource_t first_rsc, char first_task,
	pe_action_t first_action, pe_resource_t then_rsc,
	char then_task, pe_action_t then_action,
	uint32_t flags, pe_working_set_t *data_set);

	G_GNUC_INTERNAL
	void pcmk__unpack_ordering(xmlNode xml_obj, pe_working_set_t data_set);

	G_GNUC_INTERNAL
	void pcmk__disable_invalid_orderings(pe_working_set_t *data_set);

	G_GNUC_INTERNAL
	void pcmk__order_stops_before_shutdown(pe_node_t *node,
	pe_action_t *shutdown_op);

	G_GNUC_INTERNAL
	void pcmk__apply_orderings(pe_working_set_t *data_set);

	G_GNUC_INTERNAL
	void pcmk__order_after_each(pe_action_t after, GList list);


	/*!
	* \internal
	* \brief Create a new ordering between two resource actions
	*
	* \param[in,out] first_rsc Resource for 'first' action
	* \param[in,out] first_task Action key for 'first' action
	* \param[in] then_rsc Resource for 'then' action
	* \param[in,out] then_task Action key for 'then' action
	* \param[in] flags Bitmask of enum pe_ordering flags
	*/
	#define pcmk__order_resource_actions(first_rsc, first_task, \
	then_rsc, then_task, flags) \
	pcmk__new_ordering((first_rsc), \
	pcmk__op_key((first_rsc)->id, (first_task), 0), \
	NULL, \
	(then_rsc), \
	pcmk__op_key((then_rsc)->id, (then_task), 0), \
	NULL, (flags), (first_rsc)->cluster)

	#define pcmk__order_starts(rsc1, rsc2, flags) \
	pcmk__order_resource_actions((rsc1), CRMD_ACTION_START, \
	(rsc2), CRMD_ACTION_START, (flags))

	#define pcmk__order_stops(rsc1, rsc2, flags) \
	pcmk__order_resource_actions((rsc1), CRMD_ACTION_STOP, \
	(rsc2), CRMD_ACTION_STOP, (flags))


	// Ticket constraints (pcmk_sched_tickets.c)

	G_GNUC_INTERNAL
	void pcmk__unpack_rsc_ticket(xmlNode xml_obj, pe_working_set_t data_set);


	// Promotable clone resources (pcmk_sched_promotable.c)

	G_GNUC_INTERNAL
	void pcmk__add_promotion_scores(pe_resource_t *rsc);

	G_GNUC_INTERNAL
	void pcmk__require_promotion_tickets(pe_resource_t *rsc);

	G_GNUC_INTERNAL
	void pcmk__set_instance_roles(pe_resource_t *rsc);

	G_GNUC_INTERNAL
	void pcmk__create_promotable_actions(pe_resource_t *clone);

	G_GNUC_INTERNAL
	void pcmk__promotable_restart_ordering(pe_resource_t *rsc);

	G_GNUC_INTERNAL
	void pcmk__order_promotable_instances(pe_resource_t *clone);

	G_GNUC_INTERNAL
	void pcmk__update_dependent_with_promotable(const pe_resource_t *primary,
	pe_resource_t *dependent,
	const pcmk__colocation_t *colocation);

	G_GNUC_INTERNAL
	void pcmk__update_promotable_dependent_priority(const pe_resource_t *primary,
	pe_resource_t *dependent,
	const pcmk__colocation_t *colocation);


	// Pacemaker Remote nodes (pcmk_sched_remote.c)

	G_GNUC_INTERNAL
	bool pcmk__is_failed_remote_node(const pe_node_t *node);

	G_GNUC_INTERNAL
	void pcmk__order_remote_connection_actions(pe_working_set_t *data_set);

	G_GNUC_INTERNAL
	bool pcmk__rsc_corresponds_to_guest(const pe_resource_t *rsc,
	const pe_node_t *node);

	G_GNUC_INTERNAL
	pe_node_t pcmk__connection_host_for_action(const pe_action_t action);

	G_GNUC_INTERNAL
	void pcmk__substitute_remote_addr(pe_resource_t rsc, GHashTable params);

	G_GNUC_INTERNAL
	void pcmk__add_bundle_meta_to_xml(xmlNode args_xml, const pe_action_t action);


	// Primitives (pcmk_sched_primitive.c)

	G_GNUC_INTERNAL
	pe_node_t pcmk__primitive_assign(pe_resource_t rsc, const pe_node_t *prefer);

	G_GNUC_INTERNAL
	void pcmk__primitive_create_actions(pe_resource_t *rsc);

	G_GNUC_INTERNAL
	void pcmk__primitive_internal_constraints(pe_resource_t *rsc);

	G_GNUC_INTERNAL
	enum pe_action_flags pcmk__primitive_action_flags(pe_action_t *action,
	const pe_node_t *node);

	G_GNUC_INTERNAL
	void pcmk__primitive_apply_coloc_score(pe_resource_t *dependent,
	const pe_resource_t *primary,
	const pcmk__colocation_t *colocation,
	bool for_dependent);

	G_GNUC_INTERNAL
	void pcmk__with_primitive_colocations(const pe_resource_t *rsc,
	const pe_resource_t child, GList *list);

	G_GNUC_INTERNAL
	void pcmk__primitive_with_colocations(const pe_resource_t *rsc,
	const pe_resource_t child, GList *list);

	G_GNUC_INTERNAL
	void pcmk__schedule_cleanup(pe_resource_t rsc, const pe_node_t node,
	bool optional);

	G_GNUC_INTERNAL
	void pcmk__primitive_add_graph_meta(const pe_resource_t rsc, xmlNode xml);

	G_GNUC_INTERNAL
	void pcmk__primitive_add_utilization(const pe_resource_t *rsc,
	const pe_resource_t *orig_rsc,
	GList all_rscs, GHashTable utilization);

	G_GNUC_INTERNAL
	void pcmk__primitive_shutdown_lock(pe_resource_t *rsc);


	// Groups (pcmk_sched_group.c)

	G_GNUC_INTERNAL
	pe_node_t pcmk__group_assign(pe_resource_t rsc, const pe_node_t *prefer);

	G_GNUC_INTERNAL
	void pcmk__group_create_actions(pe_resource_t *rsc);

	G_GNUC_INTERNAL
	void pcmk__group_internal_constraints(pe_resource_t *rsc);

	G_GNUC_INTERNAL
	void pcmk__group_apply_coloc_score(pe_resource_t *dependent,
	const pe_resource_t *primary,
	const pcmk__colocation_t *colocation,
	bool for_dependent);

	G_GNUC_INTERNAL
	void pcmk__with_group_colocations(const pe_resource_t *rsc,
	const pe_resource_t child, GList *list);

	G_GNUC_INTERNAL
	void pcmk__group_with_colocations(const pe_resource_t *rsc,
	const pe_resource_t child, GList *list);

	G_GNUC_INTERNAL
	void pcmk__group_apply_location(pe_resource_t rsc, pe__location_t location);

	G_GNUC_INTERNAL
	enum pe_action_flags pcmk__group_action_flags(pe_action_t *action,
	const pe_node_t *node);

	G_GNUC_INTERNAL
	uint32_t pcmk__group_update_ordered_actions(pe_action_t *first,
	pe_action_t *then,
	const pe_node_t *node,
	uint32_t flags, uint32_t filter,
	uint32_t type,
	pe_working_set_t *data_set);

	G_GNUC_INTERNAL
	GList pcmk__group_colocated_resources(const pe_resource_t rsc,
	const pe_resource_t *orig_rsc,
	GList *colocated_rscs);

	G_GNUC_INTERNAL
	void pcmk__group_add_utilization(const pe_resource_t *rsc,
	const pe_resource_t orig_rsc, GList all_rscs,
	GHashTable *utilization);

	G_GNUC_INTERNAL
	void pcmk__group_shutdown_lock(pe_resource_t *rsc);


	// Clones (pcmk_sched_clone.c)

	G_GNUC_INTERNAL
	bool pcmk__is_everywhere(const pe_resource_t *collective);

	G_GNUC_INTERNAL
	void pcmk__clone_apply_coloc_score(pe_resource_t *dependent,
	const pe_resource_t *primary,
	const pcmk__colocation_t *colocation,
	bool for_dependent);

	G_GNUC_INTERNAL
	void pcmk__with_clone_colocations(const pe_resource_t *rsc,
	const pe_resource_t child, GList *list);

	G_GNUC_INTERNAL
	void pcmk__clone_with_colocations(const pe_resource_t *rsc,
	const pe_resource_t child, GList *list);

	// Bundles (pcmk_sched_bundle.c)

	G_GNUC_INTERNAL
	const pe_resource_t pcmk__get_rsc_in_container(const pe_resource_t instance);

	G_GNUC_INTERNAL
	void pcmk__bundle_apply_coloc_score(pe_resource_t *dependent,
	const pe_resource_t *primary,
	const pcmk__colocation_t *colocation,
	bool for_dependent);

	G_GNUC_INTERNAL
	void pcmk__with_bundle_colocations(const pe_resource_t *rsc,
	const pe_resource_t child, GList *list);

	G_GNUC_INTERNAL
	void pcmk__bundle_with_colocations(const pe_resource_t *rsc,
	const pe_resource_t child, GList *list);

	G_GNUC_INTERNAL
	void pcmk__output_bundle_actions(pe_resource_t *rsc);


	// Clone instances or bundle replica containers (pcmk_sched_instances.c)

	G_GNUC_INTERNAL
	void pcmk__assign_instances(pe_resource_t collective, GList instances,
	int max_total, int max_per_node);

	G_GNUC_INTERNAL
	void pcmk__create_instance_actions(pe_resource_t rsc, GList instances,
	notify_data_t **start_notify,
	notify_data_t **stop_notify);

	G_GNUC_INTERNAL
	bool pcmk__instance_matches(const pe_resource_t *instance,
	const pe_node_t *node, enum rsc_role_e role,
	bool current);

	G_GNUC_INTERNAL
	pe_resource_t pcmk__find_compatible_instance(const pe_resource_t match_rsc,
	const pe_resource_t *rsc,
	enum rsc_role_e role,
	bool current);

	G_GNUC_INTERNAL
	uint32_t pcmk__instance_update_ordered_actions(pe_action_t *first,
	pe_action_t *then,
	const pe_node_t *node,
	uint32_t flags, uint32_t filter,
	uint32_t type,
	pe_working_set_t *data_set);

	G_GNUC_INTERNAL
	enum pe_action_flags pcmk__collective_action_flags(pe_action_t *action,
	const GList *instances,
	const pe_node_t *node);

	G_GNUC_INTERNAL
	void pcmk__add_collective_constraints(GList **list,
	const pe_resource_t *instance,
	const pe_resource_t *collective,
	bool with_this);


	// Injections (pcmk_injections.c)

	G_GNUC_INTERNAL
	xmlNode pcmk__inject_node(cib_t cib_conn, const char node, const char uuid);

	G_GNUC_INTERNAL
	xmlNode pcmk__inject_node_state_change(cib_t cib_conn, const char *node,
	bool up);

	G_GNUC_INTERNAL
	xmlNode pcmk__inject_resource_history(pcmk__output_t out, xmlNode *cib_node,
	const char *resource,
	const char *lrm_name,
	const char *rclass,
	const char *rtype,
	const char *rprovider);

	G_GNUC_INTERNAL
	void pcmk__inject_failcount(pcmk__output_t out, xmlNode cib_node,
	const char resource, const char task,
	guint interval_ms, int rc);

	G_GNUC_INTERNAL
	xmlNode pcmk__inject_action_result(xmlNode cib_resource,
	lrmd_event_data_t *op, int target_rc);


	// Nodes (pcmk_sched_nodes.c)

	G_GNUC_INTERNAL
	bool pcmk__node_available(const pe_node_t *node, bool consider_score,
	bool consider_guest);

	G_GNUC_INTERNAL
	bool pcmk__any_node_available(GHashTable *nodes);

	G_GNUC_INTERNAL
	GHashTable pcmk__copy_node_table(GHashTable nodes);

	G_GNUC_INTERNAL
	GList pcmk__sort_nodes(GList nodes, pe_node_t *active_node);

	G_GNUC_INTERNAL
	void pcmk__apply_node_health(pe_working_set_t *data_set);

	G_GNUC_INTERNAL
	pe_node_t pcmk__top_allowed_node(const pe_resource_t rsc,
	const pe_node_t *node);


	// Functions applying to more than one variant (pcmk_sched_resource.c)

	G_GNUC_INTERNAL
	void pcmk__set_allocation_methods(pe_working_set_t *data_set);

	G_GNUC_INTERNAL
	bool pcmk__rsc_agent_changed(pe_resource_t rsc, pe_node_t node,
	const xmlNode *rsc_entry, bool active_on_node);

	G_GNUC_INTERNAL
	GList pcmk__rscs_matching_id(const char id, const pe_working_set_t *data_set);

	G_GNUC_INTERNAL
	GList pcmk__colocated_resources(const pe_resource_t rsc,
	const pe_resource_t *orig_rsc,
	GList *colocated_rscs);

	G_GNUC_INTERNAL
	void pcmk__noop_add_graph_meta(const pe_resource_t rsc, xmlNode xml);

	G_GNUC_INTERNAL
	void pcmk__output_resource_actions(pe_resource_t *rsc);

	G_GNUC_INTERNAL
	bool pcmk__finalize_assignment(pe_resource_t rsc, pe_node_t chosen,
	bool force);

	G_GNUC_INTERNAL
	bool pcmk__assign_resource(pe_resource_t rsc, pe_node_t node, bool force);

	G_GNUC_INTERNAL
	void pcmk__unassign_resource(pe_resource_t *rsc);

	G_GNUC_INTERNAL
	bool pcmk__threshold_reached(pe_resource_t rsc, const pe_node_t node,
	pe_resource_t **failed);

	G_GNUC_INTERNAL
	void pcmk__sort_resources(pe_working_set_t *data_set);

	G_GNUC_INTERNAL
	gint pcmk__cmp_instance(gconstpointer a, gconstpointer b);

	G_GNUC_INTERNAL
	gint pcmk__cmp_instance_number(gconstpointer a, gconstpointer b);


	// Functions related to probes (pcmk_sched_probes.c)

	G_GNUC_INTERNAL
	bool pcmk__probe_rsc_on_node(pe_resource_t rsc, pe_node_t node);

	G_GNUC_INTERNAL
	void pcmk__order_probes(pe_working_set_t *data_set);

	G_GNUC_INTERNAL
	bool pcmk__probe_resource_list(GList rscs, pe_node_t node);

	G_GNUC_INTERNAL
	void pcmk__schedule_probes(pe_working_set_t *data_set);


	// Functions related to live migration (pcmk_sched_migration.c)

	void pcmk__create_migration_actions(pe_resource_t *rsc,
	const pe_node_t *current);

	void pcmk__abort_dangling_migration(void data, void user_data);

	bool pcmk__rsc_can_migrate(const pe_resource_t rsc, const pe_node_t current);

	void pcmk__order_migration_equivalents(pe__ordering_t *order);


	// Functions related to node utilization (pcmk_sched_utilization.c)

	G_GNUC_INTERNAL
	int pcmk__compare_node_capacities(const pe_node_t *node1,
	const pe_node_t *node2);

	G_GNUC_INTERNAL
	void pcmk__consume_node_capacity(GHashTable *current_utilization,
	const pe_resource_t *rsc);

	G_GNUC_INTERNAL
	void pcmk__release_node_capacity(GHashTable *current_utilization,
	const pe_resource_t *rsc);

	G_GNUC_INTERNAL
	const pe_node_t pcmk__ban_insufficient_capacity(pe_resource_t rsc);

	G_GNUC_INTERNAL
	void pcmk__create_utilization_constraints(pe_resource_t *rsc,
	const GList *allowed_nodes);

	G_GNUC_INTERNAL
	void pcmk__show_node_capacities(const char desc, pe_working_set_t data_set);

	#endif // PCMK__LIBPACEMAKER_PRIVATE__H
	diff --git a/lib/pacemaker/pcmk_sched_colocation.c b/lib/pacemaker/pcmk_sched_colocation.c
	index 197b0a4f9e..d82257a030 100644
	--- a/lib/pacemaker/pcmk_sched_colocation.c
	+++ b/lib/pacemaker/pcmk_sched_colocation.c
	@@ -1,1583 +1,1601 @@
	/*
	* 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 General Public License version 2
	* or later (GPLv2+) WITHOUT ANY WARRANTY.
	*/

	#include <crm_internal.h>

	#include <stdbool.h>
	#include <glib.h>

	#include <crm/crm.h>
	#include <crm/pengine/status.h>
	#include <pacemaker-internal.h>

	#include "crm/common/util.h"
	#include "crm/common/xml_internal.h"
	#include "crm/msg_xml.h"
	#include "libpacemaker_private.h"

	#define EXPAND_CONSTRAINT_IDREF(__set, __rsc, __name) do { \
	__rsc = pcmk__find_constraint_resource(data_set->resources, __name); \
	if (__rsc == NULL) { \
	pcmk__config_err("%s: No resource found for %s", __set, __name); \
	return; \
	} \
	} while(0)

	// Used to temporarily mark a node as unusable
	#define INFINITY_HACK (INFINITY * -100)

	static gint
	cmp_dependent_priority(gconstpointer a, gconstpointer b)
	{
	const pcmk__colocation_t rsc_constraint1 = (const pcmk__colocation_t ) a;
	const pcmk__colocation_t rsc_constraint2 = (const pcmk__colocation_t ) b;

	if (a == NULL) {
	return 1;
	}
	if (b == NULL) {
	return -1;
	}

	CRM_ASSERT(rsc_constraint1->dependent != NULL);
	CRM_ASSERT(rsc_constraint1->primary != NULL);

	if (rsc_constraint1->dependent->priority > rsc_constraint2->dependent->priority) {
	return -1;
	}

	if (rsc_constraint1->dependent->priority < rsc_constraint2->dependent->priority) {
	return 1;
	}

	/* Process clones before primitives and groups */
	if (rsc_constraint1->dependent->variant > rsc_constraint2->dependent->variant) {
	return -1;
	}
	if (rsc_constraint1->dependent->variant < rsc_constraint2->dependent->variant) {
	return 1;
	}

	/* @COMPAT scheduler <2.0.0: Process promotable clones before nonpromotable
	* clones (probably unnecessary, but avoids having to update regression
	* tests)
	*/
	if (rsc_constraint1->dependent->variant == pe_clone) {
	if (pcmk_is_set(rsc_constraint1->dependent->flags, pe_rsc_promotable)
	&& !pcmk_is_set(rsc_constraint2->dependent->flags, pe_rsc_promotable)) {
	return -1;
	} else if (!pcmk_is_set(rsc_constraint1->dependent->flags, pe_rsc_promotable)
	&& pcmk_is_set(rsc_constraint2->dependent->flags, pe_rsc_promotable)) {
	return 1;
	}
	}

	return strcmp(rsc_constraint1->dependent->id,
	rsc_constraint2->dependent->id);
	}

	static gint
	cmp_primary_priority(gconstpointer a, gconstpointer b)
	{
	const pcmk__colocation_t rsc_constraint1 = (const pcmk__colocation_t ) a;
	const pcmk__colocation_t rsc_constraint2 = (const pcmk__colocation_t ) b;

	if (a == NULL) {
	return 1;
	}
	if (b == NULL) {
	return -1;
	}

	CRM_ASSERT(rsc_constraint1->dependent != NULL);
	CRM_ASSERT(rsc_constraint1->primary != NULL);

	if (rsc_constraint1->primary->priority > rsc_constraint2->primary->priority) {
	return -1;
	}

	if (rsc_constraint1->primary->priority < rsc_constraint2->primary->priority) {
	return 1;
	}

	/* Process clones before primitives and groups */
	if (rsc_constraint1->primary->variant > rsc_constraint2->primary->variant) {
	return -1;
	} else if (rsc_constraint1->primary->variant < rsc_constraint2->primary->variant) {
	return 1;
	}

	/* @COMPAT scheduler <2.0.0: Process promotable clones before nonpromotable
	* clones (probably unnecessary, but avoids having to update regression
	* tests)
	*/
	if (rsc_constraint1->primary->variant == pe_clone) {
	if (pcmk_is_set(rsc_constraint1->primary->flags, pe_rsc_promotable)
	&& !pcmk_is_set(rsc_constraint2->primary->flags, pe_rsc_promotable)) {
	return -1;
	} else if (!pcmk_is_set(rsc_constraint1->primary->flags, pe_rsc_promotable)
	&& pcmk_is_set(rsc_constraint2->primary->flags, pe_rsc_promotable)) {
	return 1;
	}
	}

	return strcmp(rsc_constraint1->primary->id, rsc_constraint2->primary->id);
	}

	/*!
	* \internal
	* \brief Add a "this with" colocation constraint to a sorted list
	*
	* \param[in,out] list List of constraints to add \p colocation to
	* \param[in] colocation Colocation constraint to add to \p list
	*/
	void
	pcmk__add_this_with(GList *list, const pcmk__colocation_t colocation)
	{
	crm_trace("Adding colocation %s (%s with %s%s%s @%d) "
	"to 'this with' list",
	colocation->id, colocation->dependent->id,
	colocation->primary->id,
	(colocation->node_attribute == NULL)? "" : " using ",
	pcmk__s(colocation->node_attribute, ""),
	colocation->score);
	list = g_list_insert_sorted(list, (gpointer) colocation,
	cmp_primary_priority);
	}

	/*!
	* \internal
	* \brief Add a list of "this with" colocation constraints to a list
	*
	* \param[in,out] list List of constraints to add \p addition to
	* \param[in] addition List of colocation constraints to add to \p list
	*/
	void
	pcmk__add_this_with_list(GList *list, GList addition)
	{
	CRM_CHECK((list != NULL), return);

	if (*list == NULL) { // Trivial case for efficiency
	crm_trace("Copying %u 'this with' colocations to new list",
	g_list_length(addition));
	*list = g_list_copy(addition);
	} else {
	while (addition != NULL) {
	pcmk__add_this_with(list, addition->data);
	addition = addition->next;
	}
	}
	}

	/*!
	* \internal
	* \brief Add a "with this" colocation constraint to a sorted list
	*
	* \param[in,out] list List of constraints to add \p colocation to
	* \param[in] colocation Colocation constraint to add to \p list
	*/
	void
	pcmk__add_with_this(GList *list, const pcmk__colocation_t colocation)
	{
	crm_trace("Adding colocation %s (%s with %s%s%s @%d) "
	"to 'with this' list",
	colocation->id, colocation->dependent->id,
	colocation->primary->id,
	(colocation->node_attribute == NULL)? "" : " using ",
	pcmk__s(colocation->node_attribute, ""),
	colocation->score);
	list = g_list_insert_sorted(list, (gpointer) colocation,
	cmp_dependent_priority);
	}

	/*!
	* \internal
	* \brief Add a list of "with this" colocation constraints to a list
	*
	* \param[in,out] list List of constraints to add \p addition to
	* \param[in] addition List of colocation constraints to add to \p list
	*/
	void
	pcmk__add_with_this_list(GList *list, GList addition)
	{
	CRM_CHECK((list != NULL), return);

	if (*list == NULL) { // Trivial case for efficiency
	crm_trace("Copying %u 'with this' colocations to new list",
	g_list_length(addition));
	*list = g_list_copy(addition);
	} else {
	while (addition != NULL) {
	pcmk__add_with_this(list, addition->data);
	addition = addition->next;
	}
	}
	}

	/*!
	* \internal
	* \brief Add orderings necessary for an anti-colocation constraint
	*
	* \param[in,out] first_rsc One resource in an anti-colocation
	* \param[in] first_role Anti-colocation role of \p first_rsc
	* \param[in] then_rsc Other resource in the anti-colocation
	* \param[in] then_role Anti-colocation role of \p then_rsc
	*/
	static void
	anti_colocation_order(pe_resource_t *first_rsc, int first_role,
	pe_resource_t *then_rsc, int then_role)
	{
	const char *first_tasks[] = { NULL, NULL };
	const char *then_tasks[] = { NULL, NULL };

	/* Actions to make first_rsc lose first_role */
	if (first_role == RSC_ROLE_PROMOTED) {
	first_tasks[0] = CRMD_ACTION_DEMOTE;

	} else {
	first_tasks[0] = CRMD_ACTION_STOP;

	if (first_role == RSC_ROLE_UNPROMOTED) {
	first_tasks[1] = CRMD_ACTION_PROMOTE;
	}
	}

	/* Actions to make then_rsc gain then_role */
	if (then_role == RSC_ROLE_PROMOTED) {
	then_tasks[0] = CRMD_ACTION_PROMOTE;

	} else {
	then_tasks[0] = CRMD_ACTION_START;

	if (then_role == RSC_ROLE_UNPROMOTED) {
	then_tasks[1] = CRMD_ACTION_DEMOTE;
	}
	}

	for (int first_lpc = 0;
	(first_lpc <= 1) && (first_tasks[first_lpc] != NULL); first_lpc++) {

	for (int then_lpc = 0;
	(then_lpc <= 1) && (then_tasks[then_lpc] != NULL); then_lpc++) {

	pcmk__order_resource_actions(first_rsc, first_tasks[first_lpc],
	then_rsc, then_tasks[then_lpc],
	pe_order_anti_colocation);
	}
	}
	}

	/*!
	* \internal
	* \brief Add a new colocation constraint to a cluster working set
	*
	* \param[in] id XML ID for this constraint
	* \param[in] node_attr Colocate by this attribute (NULL for #uname)
	* \param[in] score Constraint score
	* \param[in,out] dependent Resource to be colocated
	* \param[in,out] primary Resource to colocate \p dependent with
	* \param[in] dependent_role Current role of \p dependent
	* \param[in] primary_role Current role of \p primary
	* \param[in] influence Whether colocation constraint has influence
	* \param[in,out] data_set Cluster working set to add constraint to
	*/
	void
	pcmk__new_colocation(const char id, const char node_attr, int score,
	pe_resource_t dependent, pe_resource_t primary,
	const char dependent_role, const char primary_role,
	bool influence, pe_working_set_t *data_set)
	{
	pcmk__colocation_t *new_con = NULL;

	if (score == 0) {
	crm_trace("Ignoring colocation '%s' because score is 0", id);
	return;
	}
	if ((dependent == NULL) \|\| (primary == NULL)) {
	pcmk__config_err("Ignoring colocation '%s' because resource "
	"does not exist", id);
	return;
	}

	new_con = calloc(1, sizeof(pcmk__colocation_t));
	if (new_con == NULL) {
	return;
	}

	if (pcmk__str_eq(dependent_role, RSC_ROLE_STARTED_S,
	pcmk__str_null_matches\|pcmk__str_casei)) {
	dependent_role = RSC_ROLE_UNKNOWN_S;
	}

	if (pcmk__str_eq(primary_role, RSC_ROLE_STARTED_S,
	pcmk__str_null_matches\|pcmk__str_casei)) {
	primary_role = RSC_ROLE_UNKNOWN_S;
	}

	new_con->id = id;
	new_con->dependent = dependent;
	new_con->primary = primary;
	new_con->score = score;
	new_con->dependent_role = text2role(dependent_role);
	new_con->primary_role = text2role(primary_role);
	new_con->node_attribute = node_attr;
	new_con->influence = influence;

	if (node_attr == NULL) {
	node_attr = CRM_ATTR_UNAME;
	}

	pe_rsc_trace(dependent, "%s ==> %s (%s %d)",
	dependent->id, primary->id, node_attr, score);

	pcmk__add_this_with(&(dependent->rsc_cons), new_con);
	pcmk__add_with_this(&(primary->rsc_cons_lhs), new_con);

	data_set->colocation_constraints = g_list_append(data_set->colocation_constraints,
	new_con);

	if (score <= -INFINITY) {
	anti_colocation_order(dependent, new_con->dependent_role, primary,
	new_con->primary_role);
	anti_colocation_order(primary, new_con->primary_role, dependent,
	new_con->dependent_role);
	}
	}

	/*!
	* \internal
	* \brief Return the boolean influence corresponding to configuration
	*
	* \param[in] coloc_id Colocation XML ID (for error logging)
	* \param[in] rsc Resource involved in constraint (for default)
	* \param[in] influence_s String value of influence option
	*
	* \return true if string evaluates true, false if string evaluates false,
	* or value of resource's critical option if string is NULL or invalid
	*/
	static bool
	unpack_influence(const char coloc_id, const pe_resource_t rsc,
	const char *influence_s)
	{
	if (influence_s != NULL) {
	int influence_i = 0;

	if (crm_str_to_boolean(influence_s, &influence_i) < 0) {
	pcmk__config_err("Constraint '%s' has invalid value for "
	XML_COLOC_ATTR_INFLUENCE " (using default)",
	coloc_id);
	} else {
	return (influence_i != 0);
	}
	}
	return pcmk_is_set(rsc->flags, pe_rsc_critical);
	}

	static void
	unpack_colocation_set(xmlNode set, int score, const char coloc_id,
	const char influence_s, pe_working_set_t data_set)
	{
	xmlNode *xml_rsc = NULL;
	pe_resource_t *with = NULL;
	pe_resource_t *resource = NULL;
	const char *set_id = ID(set);
	const char *role = crm_element_value(set, "role");
	const char *ordering = crm_element_value(set, "ordering");
	int local_score = score;
	bool sequential = false;

	const char *score_s = crm_element_value(set, XML_RULE_ATTR_SCORE);

	if (score_s) {
	local_score = char2score(score_s);
	}
	if (local_score == 0) {
	crm_trace("Ignoring colocation '%s' for set '%s' because score is 0",
	coloc_id, set_id);
	return;
	}

	if (ordering == NULL) {
	ordering = "group";
	}

	if (pcmk__xe_get_bool_attr(set, "sequential", &sequential) == pcmk_rc_ok && !sequential) {
	return;

	} else if ((local_score > 0)
	&& pcmk__str_eq(ordering, "group", pcmk__str_casei)) {
	for (xml_rsc = first_named_child(set, XML_TAG_RESOURCE_REF);
	xml_rsc != NULL; xml_rsc = crm_next_same_xml(xml_rsc)) {

	EXPAND_CONSTRAINT_IDREF(set_id, resource, ID(xml_rsc));
	if (with != NULL) {
	pe_rsc_trace(resource, "Colocating %s with %s", resource->id, with->id);
	pcmk__new_colocation(set_id, NULL, local_score, resource,
	with, role, role,
	unpack_influence(coloc_id, resource,
	influence_s), data_set);
	}
	with = resource;
	}

	} else if (local_score > 0) {
	pe_resource_t *last = NULL;

	for (xml_rsc = first_named_child(set, XML_TAG_RESOURCE_REF);
	xml_rsc != NULL; xml_rsc = crm_next_same_xml(xml_rsc)) {

	EXPAND_CONSTRAINT_IDREF(set_id, resource, ID(xml_rsc));
	if (last != NULL) {
	pe_rsc_trace(resource, "Colocating %s with %s",
	last->id, resource->id);
	pcmk__new_colocation(set_id, NULL, local_score, last,
	resource, role, role,
	unpack_influence(coloc_id, last,
	influence_s), data_set);
	}

	last = resource;
	}

	} else {
	/* Anti-colocating with every prior resource is
	* the only way to ensure the intuitive result
	* (i.e. that no one in the set can run with anyone else in the set)
	*/

	for (xml_rsc = first_named_child(set, XML_TAG_RESOURCE_REF);
	xml_rsc != NULL; xml_rsc = crm_next_same_xml(xml_rsc)) {

	xmlNode *xml_rsc_with = NULL;
	bool influence = true;

	EXPAND_CONSTRAINT_IDREF(set_id, resource, ID(xml_rsc));
	influence = unpack_influence(coloc_id, resource, influence_s);

	for (xml_rsc_with = first_named_child(set, XML_TAG_RESOURCE_REF);
	xml_rsc_with != NULL;
	xml_rsc_with = crm_next_same_xml(xml_rsc_with)) {

	if (pcmk__str_eq(resource->id, ID(xml_rsc_with),
	pcmk__str_casei)) {
	break;
	}
	EXPAND_CONSTRAINT_IDREF(set_id, with, ID(xml_rsc_with));
	pe_rsc_trace(resource, "Anti-Colocating %s with %s", resource->id,
	with->id);
	pcmk__new_colocation(set_id, NULL, local_score,
	resource, with, role, role,
	influence, data_set);
	}
	}
	}
	}

	static void
	colocate_rsc_sets(const char id, xmlNode set1, xmlNode *set2, int score,
	const char influence_s, pe_working_set_t data_set)
	{
	xmlNode *xml_rsc = NULL;
	pe_resource_t *rsc_1 = NULL;
	pe_resource_t *rsc_2 = NULL;

	const char *role_1 = crm_element_value(set1, "role");
	const char *role_2 = crm_element_value(set2, "role");

	int rc = pcmk_rc_ok;
	bool sequential = false;

	if (score == 0) {
	crm_trace("Ignoring colocation '%s' between sets because score is 0",
	id);
	return;
	}

	rc = pcmk__xe_get_bool_attr(set1, "sequential", &sequential);
	if (rc != pcmk_rc_ok \|\| sequential) {
	// Get the first one
	xml_rsc = first_named_child(set1, XML_TAG_RESOURCE_REF);
	if (xml_rsc != NULL) {
	EXPAND_CONSTRAINT_IDREF(id, rsc_1, ID(xml_rsc));
	}
	}

	rc = pcmk__xe_get_bool_attr(set2, "sequential", &sequential);
	if (rc != pcmk_rc_ok \|\| sequential) {
	// Get the last one
	const char *rid = NULL;

	for (xml_rsc = first_named_child(set2, XML_TAG_RESOURCE_REF);
	xml_rsc != NULL; xml_rsc = crm_next_same_xml(xml_rsc)) {

	rid = ID(xml_rsc);
	}
	EXPAND_CONSTRAINT_IDREF(id, rsc_2, rid);
	}

	if ((rsc_1 != NULL) && (rsc_2 != NULL)) {
	pcmk__new_colocation(id, NULL, score, rsc_1, rsc_2, role_1, role_2,
	unpack_influence(id, rsc_1, influence_s),
	data_set);

	} else if (rsc_1 != NULL) {
	bool influence = unpack_influence(id, rsc_1, influence_s);

	for (xml_rsc = first_named_child(set2, XML_TAG_RESOURCE_REF);
	xml_rsc != NULL; xml_rsc = crm_next_same_xml(xml_rsc)) {

	EXPAND_CONSTRAINT_IDREF(id, rsc_2, ID(xml_rsc));
	pcmk__new_colocation(id, NULL, score, rsc_1, rsc_2, role_1,
	role_2, influence, data_set);
	}

	} else if (rsc_2 != NULL) {
	for (xml_rsc = first_named_child(set1, XML_TAG_RESOURCE_REF);
	xml_rsc != NULL; xml_rsc = crm_next_same_xml(xml_rsc)) {

	EXPAND_CONSTRAINT_IDREF(id, rsc_1, ID(xml_rsc));
	pcmk__new_colocation(id, NULL, score, rsc_1, rsc_2, role_1,
	role_2,
	unpack_influence(id, rsc_1, influence_s),
	data_set);
	}

	} else {
	for (xml_rsc = first_named_child(set1, XML_TAG_RESOURCE_REF);
	xml_rsc != NULL; xml_rsc = crm_next_same_xml(xml_rsc)) {

	xmlNode *xml_rsc_2 = NULL;
	bool influence = true;

	EXPAND_CONSTRAINT_IDREF(id, rsc_1, ID(xml_rsc));
	influence = unpack_influence(id, rsc_1, influence_s);

	for (xml_rsc_2 = first_named_child(set2, XML_TAG_RESOURCE_REF);
	xml_rsc_2 != NULL;
	xml_rsc_2 = crm_next_same_xml(xml_rsc_2)) {

	EXPAND_CONSTRAINT_IDREF(id, rsc_2, ID(xml_rsc_2));
	pcmk__new_colocation(id, NULL, score, rsc_1, rsc_2,
	role_1, role_2, influence,
	data_set);
	}
	}
	}
	}

	static void
	unpack_simple_colocation(xmlNode xml_obj, const char id,
	const char influence_s, pe_working_set_t data_set)
	{
	int score_i = 0;

	const char *score = crm_element_value(xml_obj, XML_RULE_ATTR_SCORE);
	const char *dependent_id = crm_element_value(xml_obj,
	XML_COLOC_ATTR_SOURCE);
	const char *primary_id = crm_element_value(xml_obj, XML_COLOC_ATTR_TARGET);
	const char *dependent_role = crm_element_value(xml_obj,
	XML_COLOC_ATTR_SOURCE_ROLE);
	const char *primary_role = crm_element_value(xml_obj,
	XML_COLOC_ATTR_TARGET_ROLE);
	const char *attr = crm_element_value(xml_obj, XML_COLOC_ATTR_NODE_ATTR);

	// @COMPAT: Deprecated since 2.1.5
	const char *dependent_instance = crm_element_value(xml_obj,
	XML_COLOC_ATTR_SOURCE_INSTANCE);
	// @COMPAT: Deprecated since 2.1.5
	const char *primary_instance = crm_element_value(xml_obj,
	XML_COLOC_ATTR_TARGET_INSTANCE);

	pe_resource_t *dependent = pcmk__find_constraint_resource(data_set->resources,
	dependent_id);
	pe_resource_t *primary = pcmk__find_constraint_resource(data_set->resources,
	primary_id);

	if (dependent_instance != NULL) {
	pe_warn_once(pe_wo_coloc_inst,
	"Support for " XML_COLOC_ATTR_SOURCE_INSTANCE " is "
	"deprecated and will be removed in a future release.");
	}

	if (primary_instance != NULL) {
	pe_warn_once(pe_wo_coloc_inst,
	"Support for " XML_COLOC_ATTR_TARGET_INSTANCE " is "
	"deprecated and will be removed in a future release.");
	}

	if (dependent == NULL) {
	pcmk__config_err("Ignoring constraint '%s' because resource '%s' "
	"does not exist", id, dependent_id);
	return;

	} else if (primary == NULL) {
	pcmk__config_err("Ignoring constraint '%s' because resource '%s' "
	"does not exist", id, primary_id);
	return;

	} else if ((dependent_instance != NULL) && !pe_rsc_is_clone(dependent)) {
	pcmk__config_err("Ignoring constraint '%s' because resource '%s' "
	"is not a clone but instance '%s' was requested",
	id, dependent_id, dependent_instance);
	return;

	} else if ((primary_instance != NULL) && !pe_rsc_is_clone(primary)) {
	pcmk__config_err("Ignoring constraint '%s' because resource '%s' "
	"is not a clone but instance '%s' was requested",
	id, primary_id, primary_instance);
	return;
	}

	if (dependent_instance != NULL) {
	dependent = find_clone_instance(dependent, dependent_instance);
	if (dependent == NULL) {
	pcmk__config_warn("Ignoring constraint '%s' because resource '%s' "
	"does not have an instance '%s'",
	id, dependent_id, dependent_instance);
	return;
	}
	}

	if (primary_instance != NULL) {
	primary = find_clone_instance(primary, primary_instance);
	if (primary == NULL) {
	pcmk__config_warn("Ignoring constraint '%s' because resource '%s' "
	"does not have an instance '%s'",
	"'%s'", id, primary_id, primary_instance);
	return;
	}
	}

	if (pcmk__xe_attr_is_true(xml_obj, XML_CONS_ATTR_SYMMETRICAL)) {
	pcmk__config_warn("The colocation constraint '"
	XML_CONS_ATTR_SYMMETRICAL
	"' attribute has been removed");
	}

	if (score) {
	score_i = char2score(score);
	}

	pcmk__new_colocation(id, attr, score_i, dependent, primary,
	dependent_role, primary_role,
	unpack_influence(id, dependent, influence_s), data_set);
	}

	// \return Standard Pacemaker return code
	static int
	unpack_colocation_tags(xmlNode xml_obj, xmlNode *expanded_xml,
	pe_working_set_t *data_set)
	{
	const char *id = NULL;
	const char *dependent_id = NULL;
	const char *primary_id = NULL;
	const char *dependent_role = NULL;
	const char *primary_role = NULL;

	pe_resource_t *dependent = NULL;
	pe_resource_t *primary = NULL;

	pe_tag_t *dependent_tag = NULL;
	pe_tag_t *primary_tag = NULL;

	xmlNode *dependent_set = NULL;
	xmlNode *primary_set = NULL;
	bool any_sets = false;

	*expanded_xml = NULL;

	CRM_CHECK(xml_obj != NULL, return EINVAL);

	id = ID(xml_obj);
	if (id == NULL) {
	pcmk__config_err("Ignoring <%s> constraint without " XML_ATTR_ID,
	crm_element_name(xml_obj));
	return pcmk_rc_unpack_error;
	}

	// Check whether there are any resource sets with template or tag references
	*expanded_xml = pcmk__expand_tags_in_sets(xml_obj, data_set);
	if (*expanded_xml != NULL) {
	crm_log_xml_trace(*expanded_xml, "Expanded rsc_colocation");
	return pcmk_rc_ok;
	}

	dependent_id = crm_element_value(xml_obj, XML_COLOC_ATTR_SOURCE);
	primary_id = crm_element_value(xml_obj, XML_COLOC_ATTR_TARGET);
	if ((dependent_id == NULL) \|\| (primary_id == NULL)) {
	return pcmk_rc_ok;
	}

	if (!pcmk__valid_resource_or_tag(data_set, dependent_id, &dependent,
	&dependent_tag)) {
	pcmk__config_err("Ignoring constraint '%s' because '%s' is not a "
	"valid resource or tag", id, dependent_id);
	return pcmk_rc_unpack_error;
	}

	if (!pcmk__valid_resource_or_tag(data_set, primary_id, &primary,
	&primary_tag)) {
	pcmk__config_err("Ignoring constraint '%s' because '%s' is not a "
	"valid resource or tag", id, primary_id);
	return pcmk_rc_unpack_error;
	}

	if ((dependent != NULL) && (primary != NULL)) {
	/* Neither side references any template/tag. */
	return pcmk_rc_ok;
	}

	if ((dependent_tag != NULL) && (primary_tag != NULL)) {
	// A colocation constraint between two templates/tags makes no sense
	pcmk__config_err("Ignoring constraint '%s' because two templates or "
	"tags cannot be colocated", id);
	return pcmk_rc_unpack_error;
	}

	dependent_role = crm_element_value(xml_obj, XML_COLOC_ATTR_SOURCE_ROLE);
	primary_role = crm_element_value(xml_obj, XML_COLOC_ATTR_TARGET_ROLE);

	*expanded_xml = copy_xml(xml_obj);

	// Convert template/tag reference in "rsc" into resource_set under constraint
	if (!pcmk__tag_to_set(*expanded_xml, &dependent_set, XML_COLOC_ATTR_SOURCE,
	true, data_set)) {
	free_xml(*expanded_xml);
	*expanded_xml = NULL;
	return pcmk_rc_unpack_error;
	}

	if (dependent_set != NULL) {
	if (dependent_role != NULL) {
	// Move "rsc-role" into converted resource_set as "role"
	crm_xml_add(dependent_set, "role", dependent_role);
	xml_remove_prop(*expanded_xml, XML_COLOC_ATTR_SOURCE_ROLE);
	}
	any_sets = true;
	}

	// Convert template/tag reference in "with-rsc" into resource_set under constraint
	if (!pcmk__tag_to_set(*expanded_xml, &primary_set, XML_COLOC_ATTR_TARGET,
	true, data_set)) {
	free_xml(*expanded_xml);
	*expanded_xml = NULL;
	return pcmk_rc_unpack_error;
	}

	if (primary_set != NULL) {
	if (primary_role != NULL) {
	// Move "with-rsc-role" into converted resource_set as "role"
	crm_xml_add(primary_set, "role", primary_role);
	xml_remove_prop(*expanded_xml, XML_COLOC_ATTR_TARGET_ROLE);
	}
	any_sets = true;
	}

	if (any_sets) {
	crm_log_xml_trace(*expanded_xml, "Expanded rsc_colocation");
	} else {
	free_xml(*expanded_xml);
	*expanded_xml = NULL;
	}

	return pcmk_rc_ok;
	}

	/*!
	* \internal
	* \brief Parse a colocation constraint from XML into a cluster working set
	*
	* \param[in,out] xml_obj Colocation constraint XML to unpack
	* \param[in,out] data_set Cluster working set to add constraint to
	*/
	void
	pcmk__unpack_colocation(xmlNode xml_obj, pe_working_set_t data_set)
	{
	int score_i = 0;
	xmlNode *set = NULL;
	xmlNode *last = NULL;

	xmlNode *orig_xml = NULL;
	xmlNode *expanded_xml = NULL;

	const char *id = crm_element_value(xml_obj, XML_ATTR_ID);
	const char *score = crm_element_value(xml_obj, XML_RULE_ATTR_SCORE);
	const char *influence_s = crm_element_value(xml_obj,
	XML_COLOC_ATTR_INFLUENCE);

	if (score) {
	score_i = char2score(score);
	}

	if (unpack_colocation_tags(xml_obj, &expanded_xml,
	data_set) != pcmk_rc_ok) {
	return;
	}
	if (expanded_xml) {
	orig_xml = xml_obj;
	xml_obj = expanded_xml;
	}

	for (set = first_named_child(xml_obj, XML_CONS_TAG_RSC_SET); set != NULL;
	set = crm_next_same_xml(set)) {

	set = expand_idref(set, data_set->input);
	if (set == NULL) { // Configuration error, message already logged
	if (expanded_xml != NULL) {
	free_xml(expanded_xml);
	}
	return;
	}

	unpack_colocation_set(set, score_i, id, influence_s, data_set);

	if (last != NULL) {
	colocate_rsc_sets(id, last, set, score_i, influence_s, data_set);
	}
	last = set;
	}

	if (expanded_xml) {
	free_xml(expanded_xml);
	xml_obj = orig_xml;
	}

	if (last == NULL) {
	unpack_simple_colocation(xml_obj, id, influence_s, data_set);
	}
	}

	/*!
	* \internal
	* \brief Make actions of a given type unrunnable for a given resource
	*
	* \param[in,out] rsc Resource whose actions should be blocked
	* \param[in] task Name of action to block
	* \param[in] reason Unrunnable start action causing the block
	*/
	static void
	mark_action_blocked(pe_resource_t rsc, const char task,
	const pe_resource_t *reason)
	{
	char *reason_text = crm_strdup_printf("colocation with %s", reason->id);

	for (GList *gIter = rsc->actions; gIter != NULL; gIter = gIter->next) {
	pe_action_t action = (pe_action_t ) gIter->data;

	if (pcmk_is_set(action->flags, pe_action_runnable)
	&& pcmk__str_eq(action->task, task, pcmk__str_casei)) {

	pe__clear_action_flags(action, pe_action_runnable);
	pe_action_set_reason(action, reason_text, false);
	pcmk__block_colocation_dependents(action, rsc->cluster);
	pcmk__update_action_for_orderings(action, rsc->cluster);
	}
	}

	// If parent resource can't perform an action, neither can any children
	for (GList *iter = rsc->children; iter != NULL; iter = iter->next) {
	mark_action_blocked((pe_resource_t *) (iter->data), task, reason);
	}
	free(reason_text);
	}

	/*!
	* \internal
	* \brief If an action is unrunnable, block any relevant dependent actions
	*
	* If a given action is an unrunnable start or promote, block the start or
	* promote actions of resources colocated with it, as appropriate to the
	* colocations' configured roles.
	*
	* \param[in,out] action Action to check
	* \param[in] data_set Cluster working set (ignored)
	*/
	void
	pcmk__block_colocation_dependents(pe_action_t *action,
	pe_working_set_t *data_set)
	{
	GList *gIter = NULL;
	pe_resource_t *rsc = NULL;
	bool is_start = false;

	if (pcmk_is_set(action->flags, pe_action_runnable)) {
	return; // Only unrunnable actions block dependents
	}

	is_start = pcmk__str_eq(action->task, RSC_START, pcmk__str_none);
	if (!is_start && !pcmk__str_eq(action->task, RSC_PROMOTE, pcmk__str_none)) {
	return; // Only unrunnable starts and promotes block dependents
	}

	CRM_ASSERT(action->rsc != NULL); // Start and promote are resource actions

	/* If this resource is part of a collective resource, dependents are blocked
	* only if all instances of the collective are unrunnable, so check the
	* collective resource.
	*/
	rsc = uber_parent(action->rsc);
	if (rsc->parent != NULL) {
	rsc = rsc->parent; // Bundle
	}

	if (rsc->rsc_cons_lhs == NULL) {
	return;
	}

	// Colocation fails only if entire primary can't reach desired role
	for (gIter = rsc->children; gIter != NULL; gIter = gIter->next) {
	pe_resource_t child = (pe_resource_t ) gIter->data;
	pe_action_t *child_action = find_first_action(child->actions, NULL,
	action->task, NULL);

	if ((child_action == NULL)
	\|\| pcmk_is_set(child_action->flags, pe_action_runnable)) {
	crm_trace("Not blocking %s colocation dependents because "
	"at least %s has runnable %s",
	rsc->id, child->id, action->task);
	return; // At least one child can reach desired role
	}
	}

	crm_trace("Blocking %s colocation dependents due to unrunnable %s %s",
	rsc->id, action->rsc->id, action->task);

	// Check each colocation where this resource is primary
	for (gIter = rsc->rsc_cons_lhs; gIter != NULL; gIter = gIter->next) {
	pcmk__colocation_t colocation = (pcmk__colocation_t ) gIter->data;

	if (colocation->score < INFINITY) {
	continue; // Only mandatory colocations block dependent
	}

	/* If the primary can't start, the dependent can't reach its colocated
	* role, regardless of what the primary or dependent colocation role is.
	*
	* If the primary can't be promoted, the dependent can't reach its
	* colocated role if the primary's colocation role is promoted.
	*/
	if (!is_start && (colocation->primary_role != RSC_ROLE_PROMOTED)) {
	continue;
	}

	// Block the dependent from reaching its colocated role
	if (colocation->dependent_role == RSC_ROLE_PROMOTED) {
	mark_action_blocked(colocation->dependent, RSC_PROMOTE,
	action->rsc);
	} else {
	mark_action_blocked(colocation->dependent, RSC_START, action->rsc);
	}
	}
	}

	/*!
	* \internal
	* \brief Determine how a colocation constraint should affect a resource
	*
	* Colocation constraints have different effects at different points in the
	* scheduler sequence. Initially, they affect a resource's location; once that
	* is determined, then for promotable clones they can affect a resource
	* instance's role; after both are determined, the constraints no longer matter.
	* Given a specific colocation constraint, check what has been done so far to
	* determine what should be affected at the current point in the scheduler.
	*
	* \param[in] dependent Dependent resource in colocation
	* \param[in] primary Primary resource in colocation
	* \param[in] colocation Colocation constraint
	* \param[in] preview If true, pretend resources have already been allocated
	*
	* \return How colocation constraint should be applied at this point
	*/
	enum pcmk__coloc_affects
	pcmk__colocation_affects(const pe_resource_t *dependent,
	const pe_resource_t *primary,
	const pcmk__colocation_t *colocation, bool preview)
	{
	if (!preview && pcmk_is_set(primary->flags, pe_rsc_provisional)) {
	// Primary resource has not been allocated yet, so we can't do anything
	return pcmk__coloc_affects_nothing;
	}

	if ((colocation->dependent_role >= RSC_ROLE_UNPROMOTED)
	&& (dependent->parent != NULL)
	&& pcmk_is_set(dependent->parent->flags, pe_rsc_promotable)
	&& !pcmk_is_set(dependent->flags, pe_rsc_provisional)) {

	/* This is a colocation by role, and the dependent is a promotable clone
	* that has already been allocated, so the colocation should now affect
	* the role.
	*/
	return pcmk__coloc_affects_role;
	}

	if (!preview && !pcmk_is_set(dependent->flags, pe_rsc_provisional)) {
	/* The dependent resource has already been through allocation, so the
	* constraint no longer has any effect. Log an error if a mandatory
	* colocation constraint has been violated.
	*/

	const pe_node_t *primary_node = primary->allocated_to;

	if (dependent->allocated_to == NULL) {
	crm_trace("Skipping colocation '%s': %s will not run anywhere",
	colocation->id, dependent->id);

	} else if (colocation->score >= INFINITY) {
	// Dependent resource must colocate with primary resource

	if ((primary_node == NULL) \|\|
	(primary_node->details != dependent->allocated_to->details)) {
	crm_err("%s must be colocated with %s but is not (%s vs. %s)",
	dependent->id, primary->id,
	pe__node_name(dependent->allocated_to),
	pe__node_name(primary_node));
	}

	} else if (colocation->score <= -CRM_SCORE_INFINITY) {
	// Dependent resource must anti-colocate with primary resource

	if ((primary_node != NULL) &&
	(dependent->allocated_to->details == primary_node->details)) {
	crm_err("%s and %s must be anti-colocated but are allocated "
	"to the same node (%s)",
	dependent->id, primary->id, pe__node_name(primary_node));
	}
	}
	return pcmk__coloc_affects_nothing;
	}

	if ((colocation->score > 0)
	&& (colocation->dependent_role != RSC_ROLE_UNKNOWN)
	&& (colocation->dependent_role != dependent->next_role)) {

	crm_trace("Skipping colocation '%s': dependent limited to %s role "
	"but %s next role is %s",
	colocation->id, role2text(colocation->dependent_role),
	dependent->id, role2text(dependent->next_role));
	return pcmk__coloc_affects_nothing;
	}

	if ((colocation->score > 0)
	&& (colocation->primary_role != RSC_ROLE_UNKNOWN)
	&& (colocation->primary_role != primary->next_role)) {

	crm_trace("Skipping colocation '%s': primary limited to %s role "
	"but %s next role is %s",
	colocation->id, role2text(colocation->primary_role),
	primary->id, role2text(primary->next_role));
	return pcmk__coloc_affects_nothing;
	}

	if ((colocation->score < 0)
	&& (colocation->dependent_role != RSC_ROLE_UNKNOWN)
	&& (colocation->dependent_role == dependent->next_role)) {
	crm_trace("Skipping anti-colocation '%s': dependent role %s matches",
	colocation->id, role2text(colocation->dependent_role));
	return pcmk__coloc_affects_nothing;
	}

	if ((colocation->score < 0)
	&& (colocation->primary_role != RSC_ROLE_UNKNOWN)
	&& (colocation->primary_role == primary->next_role)) {
	crm_trace("Skipping anti-colocation '%s': primary role %s matches",
	colocation->id, role2text(colocation->primary_role));
	return pcmk__coloc_affects_nothing;
	}

	return pcmk__coloc_affects_location;
	}

	/*!
	* \internal
	* \brief Apply colocation to dependent for allocation purposes
	*
	* Update the allowed node weights of the dependent resource in a colocation,
	* for the purposes of allocating it to a node
	*
	* \param[in,out] dependent Dependent resource in colocation
	* \param[in] primary Primary resource in colocation
	* \param[in] colocation Colocation constraint
	*/
	void
	pcmk__apply_coloc_to_weights(pe_resource_t *dependent,
	const pe_resource_t *primary,
	const pcmk__colocation_t *colocation)
	{
	const char *attribute = CRM_ATTR_ID;
	const char *value = NULL;
	GHashTable *work = NULL;
	GHashTableIter iter;
	pe_node_t *node = NULL;

	if (colocation->node_attribute != NULL) {
	attribute = colocation->node_attribute;
	}

	if (primary->allocated_to != NULL) {
	value = pe_node_attribute_raw(primary->allocated_to, attribute);

	} else if (colocation->score < 0) {
	// Nothing to do (anti-colocation with something that is not running)
	return;
	}

	work = pcmk__copy_node_table(dependent->allowed_nodes);

	g_hash_table_iter_init(&iter, work);
	while (g_hash_table_iter_next(&iter, NULL, (void **)&node)) {
	if (primary->allocated_to == NULL) {
	pe_rsc_trace(dependent, "%s: %s@%s -= %d (%s inactive)",
	colocation->id, dependent->id, pe__node_name(node),
	colocation->score, primary->id);
	node->weight = pcmk__add_scores(-colocation->score, node->weight);

	} else if (pcmk__str_eq(pe_node_attribute_raw(node, attribute), value,
	pcmk__str_casei)) {
	if (colocation->score < CRM_SCORE_INFINITY) {
	pe_rsc_trace(dependent, "%s: %s@%s += %d",
	colocation->id, dependent->id,
	pe__node_name(node), colocation->score);
	node->weight = pcmk__add_scores(colocation->score,
	node->weight);
	}

	} else if (colocation->score >= CRM_SCORE_INFINITY) {
	pe_rsc_trace(dependent, "%s: %s@%s -= %d (%s mismatch)",
	colocation->id, dependent->id, pe__node_name(node),
	colocation->score, attribute);
	node->weight = pcmk__add_scores(-colocation->score, node->weight);
	}
	}

	if ((colocation->score <= -INFINITY) \|\| (colocation->score >= INFINITY)
	\|\| pcmk__any_node_available(work)) {

	g_hash_table_destroy(dependent->allowed_nodes);
	dependent->allowed_nodes = work;
	work = NULL;

	} else {
	pe_rsc_info(dependent,
	"%s: Rolling back scores from %s (no available nodes)",
	dependent->id, primary->id);
	}

	if (work != NULL) {
	g_hash_table_destroy(work);
	}
	}

	/*!
	* \internal
	* \brief Apply colocation to dependent for role purposes
	*
	* Update the priority of the dependent resource in a colocation, for the
	* purposes of selecting its role
	*
	* \param[in,out] dependent Dependent resource in colocation
	* \param[in] primary Primary resource in colocation
	* \param[in] colocation Colocation constraint
	*/
	void
	pcmk__apply_coloc_to_priority(pe_resource_t *dependent,
	const pe_resource_t *primary,
	const pcmk__colocation_t *colocation)
	{
	const char *dependent_value = NULL;
	const char *primary_value = NULL;
	const char *attribute = CRM_ATTR_ID;
	int score_multiplier = 1;

	if ((primary->allocated_to == NULL) \|\| (dependent->allocated_to == NULL)) {
	return;
	}

	if (colocation->node_attribute != NULL) {
	attribute = colocation->node_attribute;
	}

	dependent_value = pe_node_attribute_raw(dependent->allocated_to, attribute);
	primary_value = pe_node_attribute_raw(primary->allocated_to, attribute);

	if (!pcmk__str_eq(dependent_value, primary_value, pcmk__str_casei)) {
	if ((colocation->score == INFINITY)
	&& (colocation->dependent_role == RSC_ROLE_PROMOTED)) {
	dependent->priority = -INFINITY;
	}
	return;
	}

	if ((colocation->primary_role != RSC_ROLE_UNKNOWN)
	&& (colocation->primary_role != primary->next_role)) {
	return;
	}

	if (colocation->dependent_role == RSC_ROLE_UNPROMOTED) {
	score_multiplier = -1;
	}

	dependent->priority = pcmk__add_scores(score_multiplier * colocation->score,
	dependent->priority);
	}

	/*!
	* \internal
	* \brief Find score of highest-scored node that matches colocation attribute
	*
	* \param[in] rsc Resource whose allowed nodes should be searched
	* \param[in] attr Colocation attribute name (must not be NULL)
	* \param[in] value Colocation attribute value to require
	*/
	static int
	best_node_score_matching_attr(const pe_resource_t rsc, const char attr,
	const char *value)
	{
	GHashTableIter iter;
	pe_node_t *node = NULL;
	int best_score = -INFINITY;
	const char *best_node = NULL;

	// Find best allowed node with matching attribute
	g_hash_table_iter_init(&iter, rsc->allowed_nodes);
	while (g_hash_table_iter_next(&iter, NULL, (void **) &node)) {

	if ((node->weight > best_score) && pcmk__node_available(node, false, false)
	&& pcmk__str_eq(value, pe_node_attribute_raw(node, attr), pcmk__str_casei)) {

	best_score = node->weight;
	best_node = node->details->uname;
	}
	}

	if (!pcmk__str_eq(attr, CRM_ATTR_UNAME, pcmk__str_casei)) {
	if (best_node == NULL) {
	crm_info("No allowed node for %s matches node attribute %s=%s",
	rsc->id, attr, value);
	} else {
	crm_info("Allowed node %s for %s had best score (%d) "
	"of those matching node attribute %s=%s",
	best_node, rsc->id, best_score, attr, value);
	}
	}
	return best_score;
	}

	/*!
	* \internal
	* \brief Add resource's colocation matches to current node allocation scores
	*
	* For each node in a given table, if any of a given resource's allowed nodes
	* have a matching value for the colocation attribute, add the highest of those
	* nodes' scores to the node's score.
	*
	* \param[in,out] nodes Hash table of nodes with allocation scores so far
	* \param[in] rsc Resource whose allowed nodes should be compared
	* \param[in] attr Colocation attribute that must match (NULL for default)
	* \param[in] factor Factor by which to multiply scores being added
	* \param[in] only_positive Whether to add only positive scores
	*/
	static void
	add_node_scores_matching_attr(GHashTable nodes, const pe_resource_t rsc,
	const char *attr, float factor,
	bool only_positive)
	{
	GHashTableIter iter;
	pe_node_t *node = NULL;

	if (attr == NULL) {
	attr = CRM_ATTR_UNAME;
	}

	// Iterate through each node
	g_hash_table_iter_init(&iter, nodes);
	while (g_hash_table_iter_next(&iter, NULL, (void **)&node)) {
	float weight_f = 0;
	int weight = 0;
	int score = 0;
	int new_score = 0;

	score = best_node_score_matching_attr(rsc, attr,
	pe_node_attribute_raw(node, attr));

	if ((factor < 0) && (score < 0)) {
	/* Negative preference for a node with a negative score
	* should not become a positive preference.
	*
	* @TODO Consider filtering only if weight is -INFINITY
	*/
	crm_trace("%s: Filtering %d + %f * %d (double negative disallowed)",
	pe__node_name(node), node->weight, factor, score);
	continue;
	}

	if (node->weight == INFINITY_HACK) {
	crm_trace("%s: Filtering %d + %f * %d (node was marked unusable)",
	pe__node_name(node), node->weight, factor, score);
	continue;
	}

	weight_f = factor * score;

	// Round the number; see http://c-faq.com/fp/round.html
	weight = (int) ((weight_f < 0)? (weight_f - 0.5) : (weight_f + 0.5));

	/* Small factors can obliterate the small scores that are often actually
	* used in configurations. If the score and factor are nonzero, ensure
	* that the result is nonzero as well.
	*/
	if ((weight == 0) && (score != 0)) {
	if (factor > 0.0) {
	weight = 1;
	} else if (factor < 0.0) {
	weight = -1;
	}
	}

	new_score = pcmk__add_scores(weight, node->weight);

	if (only_positive && (new_score < 0) && (node->weight > 0)) {
	crm_trace("%s: Filtering %d + %f * %d = %d "
	"(negative disallowed, marking node unusable)",
	pe__node_name(node), node->weight, factor, score,
	new_score);
	node->weight = INFINITY_HACK;
	continue;
	}

	if (only_positive && (new_score < 0) && (node->weight == 0)) {
	crm_trace("%s: Filtering %d + %f * %d = %d (negative disallowed)",
	pe__node_name(node), node->weight, factor, score,
	new_score);
	continue;
	}

	crm_trace("%s: %d + %f * %d = %d", pe__node_name(node),
	node->weight, factor, score, new_score);
	node->weight = new_score;
	}
	}

	/*!
	* \internal
	* \brief Initialize colocated node table for a group resource
	*
	* \param[in] rsc Group resource being colocated with another resource
	* \param[in] log_id Resource ID to use in log messages
	* \param[in] nodes Nodes to update
	* \param[in] attr Colocation attribute (NULL to use default)
	* \param[in] factor Incorporate scores multiplied by this factor
	* \param[in] flags Bitmask of enum pcmk__coloc_select values
	*
	* \return Table of node scores initialized for colocation, or NULL if resource
	* should be ignored for colocation purposes
	* \note The caller is responsible for freeing a non-NULL return value using
	* g_hash_table_destroy().
	*/
	static GHashTable *
	init_group_colocated_nodes(const pe_resource_t rsc, const char log_id,
	GHashTable *nodes, const char attr, float factor,
	uint32_t flags)
	{
	GHashTable *work = NULL;
	pe_resource_t *member = NULL;

	// Ignore empty groups (only possible with schema validation disabled)
	if (rsc->children == NULL) {
	return NULL;
	}

	if (*nodes == NULL) {
	// Only cmp_resources() passes a NULL nodes table
	member = pe__last_group_member(rsc);
	} else {
	/* The first member of the group will recursively incorporate any
	* constraints involving other members (including the group internal
	* colocation).
	*
	* @TODO The indirect colocations from the dependent group's other
	* members will be incorporated at full strength rather than by
	* factor, so the group's combined stickiness will be treated as
	* (factor + (#members - 1)) * stickiness. It is questionable what
	* the right approach should be.
	*/
	member = rsc->children->data;
	}

	pe_rsc_trace(rsc, "%s: Merging scores from group %s using member %s "
	"(at %.6f)", log_id, rsc->id, member->id, factor);
	work = pcmk__copy_node_table(*nodes);
	pcmk__add_colocated_node_scores(member, log_id, &work, attr, factor, flags);
	return work;
	}

	/*!
	* \internal
	* \brief Initialize colocated node table for a non-group resource
	*
	* \param[in] rsc Non-group resource being colocated with another resource
	* \param[in] log_id Resource ID to use in log messages
	* \param[in] nodes Nodes to update
	* \param[in] attr Colocation attribute (NULL to use default)
	* \param[in] factor Incorporate scores multiplied by this factor
	* \param[in] flags Bitmask of enum pcmk__coloc_select values
	*
	* \return Table of node scores initialized for colocation, or NULL if resource
	* should be ignored for colocation purposes
	* \note The caller is responsible for freeing a non-NULL return value using
	* g_hash_table_destroy().
	*/
	static GHashTable *
	init_nongroup_colocated_nodes(const pe_resource_t rsc, const char log_id,
	GHashTable *nodes, const char attr,
	float factor, uint32_t flags)
	{
	GHashTable *work = NULL;

	if (*nodes == NULL) {
	/* Only cmp_resources() passes a NULL nodes table, which indicates we
	* should initialize it with the resource's allowed node scores.
	*/
	work = pcmk__copy_node_table(rsc->allowed_nodes);

	} else {
	pe_rsc_trace(rsc, "%s: Merging scores from %s (at %.6f)",
	log_id, rsc->id, factor);
	work = pcmk__copy_node_table(*nodes);
	add_node_scores_matching_attr(work, rsc, attr, factor,
	pcmk_is_set(flags,
	pcmk__coloc_select_nonnegative));
	}
	return work;
	}

	/*!
	* \internal
	* \brief Update nodes with scores of colocated resources' nodes
	*
	* Given a table of nodes and a resource, update the nodes' scores with the
	* scores of the best nodes matching the attribute used for each of the
	* resource's relevant colocations.
	*
	* \param[in,out] rsc Resource to check colocations for
	* \param[in] log_id Resource ID to use in logs (if NULL, use \p rsc ID)
	* \param[in,out] nodes Nodes to update
	* \param[in] attr Colocation attribute (NULL to use default)
	* \param[in] factor Incorporate scores multiplied by this factor
	* \param[in] flags Bitmask of enum pcmk__coloc_select values
	*
	* \note The caller remains responsible for freeing \p *nodes.
	*/
	void
	pcmk__add_colocated_node_scores(pe_resource_t rsc, const char log_id,
	GHashTable *nodes, const char attr,
	float factor, uint32_t flags)
	{
	GHashTable *work = NULL;

	CRM_CHECK((rsc != NULL) && (nodes != NULL), return);

	if (log_id == NULL) {
	log_id = rsc->id;
	}

	// Avoid infinite recursion
	if (pcmk_is_set(rsc->flags, pe_rsc_merging)) {
	pe_rsc_info(rsc, "%s: Breaking dependency loop at %s",
	log_id, rsc->id);
	return;
	}
	pe__set_resource_flags(rsc, pe_rsc_merging);

	if (rsc->variant == pe_group) {
	work = init_group_colocated_nodes(rsc, log_id, nodes, attr, factor,
	flags);
	} else {
	work = init_nongroup_colocated_nodes(rsc, log_id, nodes, attr, factor,
	flags);
	}
	if (work == NULL) {
	pe__clear_resource_flags(rsc, pe_rsc_merging);
	return;
	}

	if (pcmk__any_node_available(work)) {
	GList *gIter = NULL;
	float multiplier = (factor < 0.0)? -1.0 : 1.0;

	if (pcmk_is_set(flags, pcmk__coloc_select_this_with)) {
	gIter = rsc->rsc_cons;
	pe_rsc_trace(rsc,
	"Checking additional %d optional '%s with' constraints",
	g_list_length(gIter), rsc->id);

	} else if (rsc->variant == pe_group) {
	pe_resource_t *last_rsc = pe__last_group_member(rsc);

	gIter = last_rsc->rsc_cons_lhs;
	pe_rsc_trace(rsc, "Checking additional %d optional 'with group %s' "
	"constraints using last member %s",
	g_list_length(gIter), rsc->id, last_rsc->id);

	} else {
	gIter = rsc->rsc_cons_lhs;
	pe_rsc_trace(rsc,
	"Checking additional %d optional 'with %s' constraints",
	g_list_length(gIter), rsc->id);
	}

	for (; gIter != NULL; gIter = gIter->next) {
	pe_resource_t *other = NULL;
	pcmk__colocation_t constraint = (pcmk__colocation_t ) gIter->data;

	if (pcmk_is_set(flags, pcmk__coloc_select_this_with)) {
	other = constraint->primary;
	} else if (!pcmk__colocation_has_influence(constraint, NULL)) {
	continue;
	} else {
	other = constraint->dependent;
	}

	pe_rsc_trace(rsc, "Optionally merging score of '%s' constraint (%s with %s)",
	constraint->id, constraint->dependent->id,
	constraint->primary->id);
	factor = multiplier * constraint->score / (float) INFINITY;
	pcmk__add_colocated_node_scores(other, log_id, &work,
	constraint->node_attribute, factor,
	flags\|pcmk__coloc_select_active);
	pe__show_node_weights(true, NULL, log_id, work, rsc->cluster);
	}

	} else if (pcmk_is_set(flags, pcmk__coloc_select_active)) {
	pe_rsc_info(rsc, "%s: Rolling back optional scores from %s",
	log_id, rsc->id);
	g_hash_table_destroy(work);
	pe__clear_resource_flags(rsc, pe_rsc_merging);
	return;
	}


	if (pcmk_is_set(flags, pcmk__coloc_select_nonnegative)) {
	pe_node_t *node = NULL;
	GHashTableIter iter;

	g_hash_table_iter_init(&iter, work);
	while (g_hash_table_iter_next(&iter, NULL, (void **)&node)) {
	if (node->weight == INFINITY_HACK) {
	node->weight = 1;
	}
	}
	}

	if (*nodes != NULL) {
	g_hash_table_destroy(*nodes);
	}
	*nodes = work;

	pe__clear_resource_flags(rsc, pe_rsc_merging);
	}
	+
	+GList *
	+pcmk__with_this_colocations(const pe_resource_t *rsc)
	+{
	+ GList *list = NULL;
	+
	+ rsc->cmds->with_this_colocations(rsc, rsc, &list);
	+ return list;
	+}
	+
	+GList *
	+pcmk__this_with_colocations(const pe_resource_t *rsc)
	+{
	+ GList *list = NULL;
	+
	+ rsc->cmds->this_with_colocations(rsc, rsc, &list);
	+ return list;
	+}

File Metadata

Mime Type: text/x-diff
Expires: Tue, Jul 8, 6:09 PM (21 h, 34 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 2002501
Default Alt Text: (115 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions