No OneTemporary
Actions

Size

67 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/include/pcmki/pcmki_sched_utils.h b/include/pcmki/pcmki_sched_utils.h
	index c158fc028c..f73a2d5d62 100644
	--- a/include/pcmki/pcmki_sched_utils.h
	+++ b/include/pcmki/pcmki_sched_utils.h
	@@ -1,73 +1,72 @@
	/*
	* Copyright 2004-2021 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 PENGINE_AUTILS__H
	# define PENGINE_AUTILS__H

	#include <stdbool.h> // bool
	#include <glib.h> // GList, GHashTable, gboolean, guint
	#include <crm/lrmd.h> // lrmd_event_data_t
	#include <crm/cib.h> // cib_t
	#include <crm/pengine/pe_types.h>
	#include <crm/pengine/internal.h>
	#include <pcmki/pcmki_scheduler.h>
	#include <pcmki/pcmki_transition.h>
	#include <pacemaker.h>

	/* Constraint helper functions */
	pcmk__colocation_t invert_constraint(pcmk__colocation_t constraint);

	pe__location_t copy_constraint(pe__location_t constraint);

	GHashTable pcmk__copy_node_table(GHashTable nodes);
	GList pcmk__copy_node_list(const GList list, bool reset);
	GList sort_nodes_by_weight(GList nodes, pe_node_t *active_node,
	pe_working_set_t *data_set);

	extern gboolean can_run_resources(const pe_node_t * node);

	-extern void log_action(unsigned int log_level, const char *pre_text,
	- pe_action_t * action, gboolean details);
	+void log_action(const char pre_text, pe_action_t action, gboolean details);

	gboolean can_run_any(GHashTable * nodes);
	pe_resource_t find_compatible_child(pe_resource_t local_child,
	pe_resource_t *rsc, enum rsc_role_e filter,
	gboolean current,
	pe_working_set_t *data_set);
	pe_resource_t find_compatible_child_by_node(pe_resource_t local_child, pe_node_t * local_node, pe_resource_t * rsc,
	enum rsc_role_e filter, gboolean current);
	gboolean is_child_compatible(pe_resource_t child_rsc, pe_node_t local_node, enum rsc_role_e filter, gboolean current);
	enum pe_action_flags summary_action_flags(pe_action_t * action, GList children, pe_node_t node);
	enum action_tasks clone_child_action(pe_action_t * action);
	int copies_per_node(pe_resource_t * rsc);

	extern int compare_capacity(const pe_node_t * node1, const pe_node_t * node2);
	extern void calculate_utilization(GHashTable * current_utilization,
	GHashTable * utilization, gboolean plus);

	extern void process_utilization(pe_resource_t * rsc, pe_node_t ** prefer, pe_working_set_t * data_set);
	pe_action_t create_pseudo_resource_op(pe_resource_t rsc, const char task, bool optional, bool runnable, pe_working_set_t data_set);
	pe_action_t pe_cancel_op(pe_resource_t rsc, const char *name,
	guint interval_ms, pe_node_t *node,
	pe_working_set_t *data_set);
	pe_action_t sched_shutdown_op(pe_node_t node, pe_working_set_t *data_set);

	xmlNode pcmk__create_history_xml(xmlNode parent, lrmd_event_data_t *event,
	const char *caller_version, int target_rc,
	const char node, const char origin,
	int level);

	# define LOAD_STOPPED "load_stopped"

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

	enum transition_status run_simulation(pe_working_set_t * data_set, cib_t cib, GList op_fail_list);

	#endif
	diff --git a/lib/pacemaker/pcmk_graph_producer.c b/lib/pacemaker/pcmk_graph_producer.c
	index 7061f37d20..64046f2a62 100644
	--- a/lib/pacemaker/pcmk_graph_producer.c
	+++ b/lib/pacemaker/pcmk_graph_producer.c
	@@ -1,988 +1,988 @@
	/*
	* Copyright 2004-2021 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 <sys/param.h>
	#include <crm/crm.h>
	#include <crm/cib.h>
	#include <crm/msg_xml.h>
	#include <crm/common/xml.h>

	#include <glib.h>

	#include <pacemaker-internal.h>

	#include "libpacemaker_private.h"

	// Convenience macros for logging action properties

	#define action_type_str(flags) \
	(pcmk_is_set((flags), pe_action_pseudo)? "pseudo-action" : "action")

	#define action_optional_str(flags) \
	(pcmk_is_set((flags), pe_action_optional)? "optional" : "required")

	#define action_runnable_str(flags) \
	(pcmk_is_set((flags), pe_action_runnable)? "runnable" : "unrunnable")

	#define action_node_str(a) \
	(((a)->node == NULL)? "no node" : (a)->node->details->uname)

	/*!
	* \internal
	* \brief Add an XML node tag for a specified ID
	*
	* \param[in] id Node UUID to add
	* \param[in,out] xml Parent XML tag to add to
	*/
	static xmlNode*
	add_node_to_xml_by_id(const char id, xmlNode xml)
	{
	xmlNode *node_xml;

	node_xml = create_xml_node(xml, XML_CIB_TAG_NODE);
	crm_xml_add(node_xml, XML_ATTR_UUID, id);

	return node_xml;
	}

	/*!
	* \internal
	* \brief Add an XML node tag for a specified node
	*
	* \param[in] node Node to add
	* \param[in,out] xml XML to add node to
	*/
	static void
	add_node_to_xml(const pe_node_t node, void xml)
	{
	add_node_to_xml_by_id(node->details->id, (xmlNode *) xml);
	}

	/*!
	* \internal
	* \brief Add XML with nodes that need an update of their maintenance state
	*
	* \param[in,out] xml Parent XML tag to add to
	* \param[in] data_set Working set for cluster
	*/
	static int
	add_maintenance_nodes(xmlNode xml, const pe_working_set_t data_set)
	{
	GList *gIter = NULL;
	xmlNode *maintenance =
	xml?create_xml_node(xml, XML_GRAPH_TAG_MAINTENANCE):NULL;
	int count = 0;

	for (gIter = data_set->nodes; gIter != NULL;
	gIter = gIter->next) {
	pe_node_t node = (pe_node_t ) gIter->data;
	struct pe_node_shared_s *details = node->details;

	if (!pe__is_guest_or_remote_node(node)) {
	continue; /* just remote nodes need to know atm */
	}

	if (details->maintenance != details->remote_maintenance) {
	if (maintenance) {
	crm_xml_add(
	add_node_to_xml_by_id(node->details->id, maintenance),
	XML_NODE_IS_MAINTENANCE, details->maintenance?"1":"0");
	}
	count++;
	}
	}
	crm_trace("%s %d nodes to adjust maintenance-mode "
	"to transition", maintenance?"Added":"Counted", count);
	return count;
	}

	/*!
	* \internal
	* \brief Add pseudo action with nodes needing maintenance state update
	*
	* \param[in,out] data_set Working set for cluster
	*/
	void
	add_maintenance_update(pe_working_set_t *data_set)
	{
	pe_action_t *action = NULL;

	if (add_maintenance_nodes(NULL, data_set)) {
	crm_trace("adding maintenance state update pseudo action");
	action = get_pseudo_op(CRM_OP_MAINTENANCE_NODES, data_set);
	pe__set_action_flags(action, pe_action_print_always);
	}
	}

	/*!
	* \internal
	* \brief Add XML with nodes that an action is expected to bring down
	*
	* If a specified action is expected to bring any nodes down, add an XML block
	* with their UUIDs. When a node is lost, this allows the controller to
	* determine whether it was expected.
	*
	* \param[in,out] xml Parent XML tag to add to
	* \param[in] action Action to check for downed nodes
	* \param[in] data_set Working set for cluster
	*/
	static void
	add_downed_nodes(xmlNode xml, const pe_action_t action,
	const pe_working_set_t *data_set)
	{
	CRM_CHECK(xml && action && action->node && data_set, return);

	if (pcmk__str_eq(action->task, CRM_OP_SHUTDOWN, pcmk__str_casei)) {

	/* Shutdown makes the action's node down */
	xmlNode *downed = create_xml_node(xml, XML_GRAPH_TAG_DOWNED);
	add_node_to_xml_by_id(action->node->details->id, downed);

	} else if (pcmk__str_eq(action->task, CRM_OP_FENCE, pcmk__str_casei)) {

	/* Fencing makes the action's node and any hosted guest nodes down */
	const char *fence = g_hash_table_lookup(action->meta, "stonith_action");

	if (pcmk__is_fencing_action(fence)) {
	xmlNode *downed = create_xml_node(xml, XML_GRAPH_TAG_DOWNED);
	add_node_to_xml_by_id(action->node->details->id, downed);
	pe_foreach_guest_node(data_set, action->node, add_node_to_xml, downed);
	}

	} else if (action->rsc && action->rsc->is_remote_node
	&& pcmk__str_eq(action->task, CRMD_ACTION_STOP, pcmk__str_casei)) {

	/* Stopping a remote connection resource makes connected node down,
	* unless it's part of a migration
	*/
	GList *iter;
	pe_action_t *input;
	gboolean migrating = FALSE;

	for (iter = action->actions_before; iter != NULL; iter = iter->next) {
	input = ((pe_action_wrapper_t *) iter->data)->action;
	if (input->rsc && pcmk__str_eq(action->rsc->id, input->rsc->id, pcmk__str_casei)
	&& pcmk__str_eq(input->task, CRMD_ACTION_MIGRATED, pcmk__str_casei)) {
	migrating = TRUE;
	break;
	}
	}
	if (!migrating) {
	xmlNode *downed = create_xml_node(xml, XML_GRAPH_TAG_DOWNED);
	add_node_to_xml_by_id(action->rsc->id, downed);
	}
	}
	}

	static bool
	should_lock_action(pe_action_t *action)
	{
	// Only actions taking place on resource's lock node are locked
	if ((action->rsc->lock_node == NULL) \|\| (action->node == NULL)
	\|\| (action->node->details != action->rsc->lock_node->details)) {
	return false;
	}

	/* During shutdown, only stops are locked (otherwise, another action such as
	* a demote would cause the controller to clear the lock)
	*/
	if (action->node->details->shutdown && action->task
	&& strcmp(action->task, RSC_STOP)) {
	return false;
	}

	return true;
	}

	static xmlNode *
	action2xml(pe_action_t * action, gboolean as_input, pe_working_set_t *data_set)
	{
	gboolean needs_node_info = TRUE;
	gboolean needs_maintenance_info = FALSE;
	xmlNode *action_xml = NULL;
	xmlNode *args_xml = NULL;
	#if ENABLE_VERSIONED_ATTRS
	pe_rsc_action_details_t *rsc_details = NULL;
	#endif

	if (action == NULL) {
	return NULL;
	}

	if (pcmk__str_eq(action->task, CRM_OP_FENCE, pcmk__str_casei)) {
	/* All fences need node info; guest node fences are pseudo-events */
	action_xml = create_xml_node(NULL,
	pcmk_is_set(action->flags, pe_action_pseudo)?
	XML_GRAPH_TAG_PSEUDO_EVENT :
	XML_GRAPH_TAG_CRM_EVENT);

	} else if (pcmk__str_eq(action->task, CRM_OP_SHUTDOWN, pcmk__str_casei)) {
	action_xml = create_xml_node(NULL, XML_GRAPH_TAG_CRM_EVENT);

	} else if (pcmk__str_eq(action->task, CRM_OP_CLEAR_FAILCOUNT, pcmk__str_casei)) {
	action_xml = create_xml_node(NULL, XML_GRAPH_TAG_CRM_EVENT);

	} else if (pcmk__str_eq(action->task, CRM_OP_LRM_REFRESH, pcmk__str_casei)) {
	action_xml = create_xml_node(NULL, XML_GRAPH_TAG_CRM_EVENT);

	} else if (pcmk__str_eq(action->task, CRM_OP_LRM_DELETE, pcmk__str_casei)) {
	// CIB-only clean-up for shutdown locks
	action_xml = create_xml_node(NULL, XML_GRAPH_TAG_CRM_EVENT);
	crm_xml_add(action_xml, PCMK__XA_MODE, XML_TAG_CIB);

	/* } else if(pcmk__str_eq(action->task, RSC_PROBED, pcmk__str_casei)) { */
	/* action_xml = create_xml_node(NULL, XML_GRAPH_TAG_CRM_EVENT); */

	} else if (pcmk_is_set(action->flags, pe_action_pseudo)) {
	if (pcmk__str_eq(action->task, CRM_OP_MAINTENANCE_NODES, pcmk__str_casei)) {
	needs_maintenance_info = TRUE;
	}
	action_xml = create_xml_node(NULL, XML_GRAPH_TAG_PSEUDO_EVENT);
	needs_node_info = FALSE;

	} else {
	action_xml = create_xml_node(NULL, XML_GRAPH_TAG_RSC_OP);

	#if ENABLE_VERSIONED_ATTRS
	rsc_details = pe_rsc_action_details(action);
	#endif
	}

	crm_xml_add_int(action_xml, XML_ATTR_ID, action->id);
	crm_xml_add(action_xml, XML_LRM_ATTR_TASK, action->task);
	if (action->rsc != NULL && action->rsc->clone_name != NULL) {
	char *clone_key = NULL;
	guint interval_ms;

	if (pcmk__guint_from_hash(action->meta,
	XML_LRM_ATTR_INTERVAL_MS, 0,
	&interval_ms) != pcmk_rc_ok) {
	interval_ms = 0;
	}

	if (pcmk__str_eq(action->task, RSC_NOTIFY, pcmk__str_casei)) {
	const char *n_type = g_hash_table_lookup(action->meta, "notify_type");
	const char *n_task = g_hash_table_lookup(action->meta, "notify_operation");

	CRM_CHECK(n_type != NULL, crm_err("No notify type value found for %s", action->uuid));
	CRM_CHECK(n_task != NULL,
	crm_err("No notify operation value found for %s", action->uuid));
	clone_key = pcmk__notify_key(action->rsc->clone_name,
	n_type, n_task);

	} else if(action->cancel_task) {
	clone_key = pcmk__op_key(action->rsc->clone_name,
	action->cancel_task, interval_ms);
	} else {
	clone_key = pcmk__op_key(action->rsc->clone_name,
	action->task, interval_ms);
	}

	CRM_CHECK(clone_key != NULL, crm_err("Could not generate a key for %s", action->uuid));
	crm_xml_add(action_xml, XML_LRM_ATTR_TASK_KEY, clone_key);
	crm_xml_add(action_xml, "internal_" XML_LRM_ATTR_TASK_KEY, action->uuid);
	free(clone_key);

	} else {
	crm_xml_add(action_xml, XML_LRM_ATTR_TASK_KEY, action->uuid);
	}

	if (needs_node_info && action->node != NULL) {
	pe_node_t *router_node = pcmk__connection_host_for_action(action);

	crm_xml_add(action_xml, XML_LRM_ATTR_TARGET, action->node->details->uname);
	crm_xml_add(action_xml, XML_LRM_ATTR_TARGET_UUID, action->node->details->id);
	if (router_node) {
	crm_xml_add(action_xml, XML_LRM_ATTR_ROUTER_NODE, router_node->details->uname);
	}

	g_hash_table_insert(action->meta, strdup(XML_LRM_ATTR_TARGET), strdup(action->node->details->uname));
	g_hash_table_insert(action->meta, strdup(XML_LRM_ATTR_TARGET_UUID), strdup(action->node->details->id));
	}

	/* No details if this action is only being listed in the inputs section */
	if (as_input) {
	return action_xml;
	}

	if (action->rsc && !pcmk_is_set(action->flags, pe_action_pseudo)) {
	int lpc = 0;
	xmlNode *rsc_xml = NULL;
	const char *attr_list[] = {
	XML_AGENT_ATTR_CLASS,
	XML_AGENT_ATTR_PROVIDER,
	XML_ATTR_TYPE
	};

	/* If a resource is locked to a node via shutdown-lock, mark its actions
	* so the controller can preserve the lock when the action completes.
	*/
	if (should_lock_action(action)) {
	crm_xml_add_ll(action_xml, XML_CONFIG_ATTR_SHUTDOWN_LOCK,
	(long long) action->rsc->lock_time);
	}

	// List affected resource

	rsc_xml = create_xml_node(action_xml,
	crm_element_name(action->rsc->xml));
	if (pcmk_is_set(action->rsc->flags, pe_rsc_orphan)
	&& action->rsc->clone_name) {
	/* Do not use the 'instance free' name here as that
	* might interfere with the instance we plan to keep.
	* Ie. if there are more than two named /anonymous/
	* instances on a given node, we need to make sure the
	* command goes to the right one.
	*
	* Keep this block, even when everyone is using
	* 'instance free' anonymous clone names - it means
	* we'll do the right thing if anyone toggles the
	* unique flag to 'off'
	*/
	crm_debug("Using orphan clone name %s instead of %s", action->rsc->id,
	action->rsc->clone_name);
	crm_xml_add(rsc_xml, XML_ATTR_ID, action->rsc->clone_name);
	crm_xml_add(rsc_xml, XML_ATTR_ID_LONG, action->rsc->id);

	} else if (!pcmk_is_set(action->rsc->flags, pe_rsc_unique)) {
	const char *xml_id = ID(action->rsc->xml);

	crm_debug("Using anonymous clone name %s for %s (aka. %s)", xml_id, action->rsc->id,
	action->rsc->clone_name);

	/* ID is what we'd like client to use
	* ID_LONG is what they might know it as instead
	*
	* ID_LONG is only strictly needed /here/ during the
	* transition period until all nodes in the cluster
	* are running the new software /and/ have rebooted
	* once (meaning that they've only ever spoken to a DC
	* supporting this feature).
	*
	* If anyone toggles the unique flag to 'on', the
	* 'instance free' name will correspond to an orphan
	* and fall into the clause above instead
	*/
	crm_xml_add(rsc_xml, XML_ATTR_ID, xml_id);
	if (action->rsc->clone_name && !pcmk__str_eq(xml_id, action->rsc->clone_name, pcmk__str_casei)) {
	crm_xml_add(rsc_xml, XML_ATTR_ID_LONG, action->rsc->clone_name);
	} else {
	crm_xml_add(rsc_xml, XML_ATTR_ID_LONG, action->rsc->id);
	}

	} else {
	CRM_ASSERT(action->rsc->clone_name == NULL);
	crm_xml_add(rsc_xml, XML_ATTR_ID, action->rsc->id);
	}

	for (lpc = 0; lpc < PCMK__NELEM(attr_list); lpc++) {
	crm_xml_add(rsc_xml, attr_list[lpc],
	g_hash_table_lookup(action->rsc->meta, attr_list[lpc]));
	}
	}

	/* List any attributes in effect */
	args_xml = create_xml_node(NULL, XML_TAG_ATTRS);
	crm_xml_add(args_xml, XML_ATTR_CRM_VERSION, CRM_FEATURE_SET);

	g_hash_table_foreach(action->extra, hash2field, args_xml);
	if (action->rsc != NULL && action->node) {
	// Get the resource instance attributes, evaluated properly for node
	GHashTable *params = pe_rsc_params(action->rsc, action->node, data_set);

	pcmk__substitute_remote_addr(action->rsc, params, data_set);

	g_hash_table_foreach(params, hash2smartfield, args_xml);

	#if ENABLE_VERSIONED_ATTRS
	{
	xmlNode *versioned_parameters = create_xml_node(NULL, XML_TAG_RSC_VER_ATTRS);

	pe_get_versioned_attributes(versioned_parameters, action->rsc,
	action->node, data_set);
	if (xml_has_children(versioned_parameters)) {
	add_node_copy(action_xml, versioned_parameters);
	}
	free_xml(versioned_parameters);
	}
	#endif

	} else if(action->rsc && action->rsc->variant <= pe_native) {
	GHashTable *params = pe_rsc_params(action->rsc, NULL, data_set);

	g_hash_table_foreach(params, hash2smartfield, args_xml);

	#if ENABLE_VERSIONED_ATTRS
	if (xml_has_children(action->rsc->versioned_parameters)) {
	add_node_copy(action_xml, action->rsc->versioned_parameters);
	}
	#endif
	}

	#if ENABLE_VERSIONED_ATTRS
	if (rsc_details) {
	if (xml_has_children(rsc_details->versioned_parameters)) {
	add_node_copy(action_xml, rsc_details->versioned_parameters);
	}

	if (xml_has_children(rsc_details->versioned_meta)) {
	add_node_copy(action_xml, rsc_details->versioned_meta);
	}
	}
	#endif

	g_hash_table_foreach(action->meta, hash2metafield, args_xml);
	if (action->rsc != NULL) {
	const char *value = g_hash_table_lookup(action->rsc->meta, "external-ip");
	pe_resource_t *parent = action->rsc;

	while (parent != NULL) {
	parent->cmds->append_meta(parent, args_xml);
	parent = parent->parent;
	}

	if(value) {
	hash2smartfield((gpointer)"pcmk_external_ip", (gpointer)value, (gpointer)args_xml);
	}

	pcmk__add_bundle_meta_to_xml(args_xml, action);

	} else if (pcmk__str_eq(action->task, CRM_OP_FENCE, pcmk__str_casei) && action->node) {
	/* Pass the node's attributes as meta-attributes.
	*
	* @TODO: Determine whether it is still necessary to do this. It was
	* added in 33d99707, probably for the libfence-based implementation in
	* c9a90bd, which is no longer used.
	*/
	g_hash_table_foreach(action->node->details->attrs, hash2metafield, args_xml);
	}

	sorted_xml(args_xml, action_xml, FALSE);
	free_xml(args_xml);

	/* List any nodes this action is expected to make down */
	if (needs_node_info && (action->node != NULL)) {
	add_downed_nodes(action_xml, action, data_set);
	}

	if (needs_maintenance_info) {
	add_maintenance_nodes(action_xml, data_set);
	}

	crm_log_xml_trace(action_xml, "dumped action");
	return action_xml;
	}

	static bool
	should_dump_action(pe_action_t *action)
	{
	CRM_CHECK(action != NULL, return false);

	if (pcmk_is_set(action->flags, pe_action_dumped)) {
	crm_trace("Action %s (%d) already dumped", action->uuid, action->id);
	return false;

	} else if (pcmk_is_set(action->flags, pe_action_pseudo)
	&& pcmk__str_eq(action->task, CRM_OP_PROBED, pcmk__str_casei)) {
	GList *lpc = NULL;

	/* This is a horrible but convenient hack
	*
	* It mimimizes the number of actions with unsatisfied inputs
	* (i.e. not included in the graph)
	*
	* This in turn, means we can be more concise when printing
	* aborted/incomplete graphs.
	*
	* It also makes it obvious which node is preventing
	* probe_complete from running (presumably because it is only
	* partially up)
	*
	* For these reasons we tolerate such perversions
	*/

	for (lpc = action->actions_after; lpc != NULL; lpc = lpc->next) {
	pe_action_wrapper_t wrapper = (pe_action_wrapper_t ) lpc->data;

	if (!pcmk_is_set(wrapper->action->flags, pe_action_runnable)) {
	/* Only interested in runnable operations */
	} else if (!pcmk__str_eq(wrapper->action->task, RSC_START, pcmk__str_casei)) {
	/* Only interested in start operations */
	} else if (pcmk_is_set(wrapper->action->flags, pe_action_dumped)
	\|\| should_dump_action(wrapper->action)) {
	crm_trace("Action %s (%d) should be dumped: "
	"dependency of %s (%d)",
	action->uuid, action->id,
	wrapper->action->uuid, wrapper->action->id);
	return true;
	}
	}
	}

	if (!pcmk_is_set(action->flags, pe_action_runnable)) {
	crm_trace("Ignoring action %s (%d): unrunnable",
	action->uuid, action->id);
	return false;

	} else if (pcmk_is_set(action->flags, pe_action_optional)
	&& !pcmk_is_set(action->flags, pe_action_print_always)) {
	crm_trace("Ignoring action %s (%d): optional",
	action->uuid, action->id);
	return false;

	// Monitors should be dumped even for unmanaged resources
	} else if (action->rsc && !pcmk_is_set(action->rsc->flags, pe_rsc_managed)
	&& !pcmk__str_eq(action->task, RSC_STATUS, pcmk__str_casei)) {

	const char *interval_ms_s = g_hash_table_lookup(action->meta,
	XML_LRM_ATTR_INTERVAL_MS);

	// Cancellation of recurring monitors should still be dumped
	if (pcmk__str_eq(interval_ms_s, "0", pcmk__str_null_matches)) {
	crm_trace("Ignoring action %s (%d): for unmanaged resource (%s)",
	action->uuid, action->id, action->rsc->id);
	return false;
	}
	}

	if (pcmk_is_set(action->flags, pe_action_pseudo) \|\|
	pcmk__strcase_any_of(action->task, CRM_OP_FENCE, CRM_OP_SHUTDOWN, NULL)) {
	/* skip the next checks */
	return true;
	}

	if (action->node == NULL) {
	pe_err("Skipping action %s (%d) "
	"because it was not allocated to a node (bug?)",
	action->uuid, action->id);
	- log_action(LOG_DEBUG, "Unallocated action", action, false);
	+ log_action("Unallocated action", action, false);
	return false;

	} else if (pcmk_is_set(action->flags, pe_action_dc)) {
	crm_trace("Action %s (%d) should be dumped: "
	"can run on DC instead of %s",
	action->uuid, action->id, action->node->details->uname);

	} else if (pe__is_guest_node(action->node)
	&& !action->node->details->remote_requires_reset) {
	crm_trace("Action %s (%d) should be dumped: "
	"assuming will be runnable on guest node %s",
	action->uuid, action->id, action->node->details->uname);

	} else if (action->node->details->online == false) {
	pe_err("Skipping action %s (%d) "
	"because it was scheduled for offline node (bug?)",
	action->uuid, action->id);
	- log_action(LOG_DEBUG, "Action for offline node", action, FALSE);
	+ log_action("Action for offline node", action, FALSE);
	return false;
	#if 0
	/* but this would also affect resources that can be safely
	* migrated before a fencing op
	*/
	} else if (action->node->details->unclean == false) {
	pe_err("Skipping action %s (%d) "
	"because it was scheduled for unclean node (bug?)",
	action->uuid, action->id);
	- log_action(LOG_DEBUG, "Action for unclean node", action, false);
	+ log_action("Action for unclean node", action, false);
	return false;
	#endif
	}
	return true;
	}

	/* lowest to highest */
	static gint
	sort_action_id(gconstpointer a, gconstpointer b)
	{
	const pe_action_wrapper_t action_wrapper2 = (const pe_action_wrapper_t )a;
	const pe_action_wrapper_t action_wrapper1 = (const pe_action_wrapper_t )b;

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

	if (action_wrapper1->action->id > action_wrapper2->action->id) {
	return -1;
	}

	if (action_wrapper1->action->id < action_wrapper2->action->id) {
	return 1;
	}
	return 0;
	}

	/*!
	* \internal
	* \brief Check whether an ordering's flags can change an action
	*
	* \param[in] ordering Ordering to check
	*
	* \return true if ordering has flags that can change an action, false otherwise
	*/
	static bool
	ordering_can_change_actions(pe_action_wrapper_t *ordering)
	{
	return pcmk_any_flags_set(ordering->type, ~(pe_order_implies_first_printed
	\|pe_order_implies_then_printed
	\|pe_order_optional));
	}

	/*!
	* \internal
	* \brief Check whether an action input should be in the transition graph
	*
	* \param[in] action Action to check
	* \param[in,out] input Action input to check
	*
	* \return true if input should be in graph, false otherwise
	* \note This function may not only check an input, but disable it under certian
	* circumstances (load or anti-colocation orderings that are not needed).
	*/
	static bool
	check_dump_input(pe_action_t action, pe_action_wrapper_t input)
	{
	if (input->state == pe_link_dumped) {
	return true;
	}

	if (input->type == pe_order_none) {
	crm_trace("Ignoring %s (%d) input %s (%d): "
	"ordering disabled",
	action->uuid, action->id,
	input->action->uuid, input->action->id);
	return false;

	} else if (!pcmk_is_set(input->action->flags, pe_action_runnable)
	&& !ordering_can_change_actions(input)
	&& !pcmk__str_eq(input->action->uuid, CRM_OP_PROBED, pcmk__str_casei)) {
	crm_trace("Ignoring %s (%d) input %s (%d): "
	"optional and input unrunnable",
	action->uuid, action->id,
	input->action->uuid, input->action->id);
	return false;

	} else if (!pcmk_is_set(input->action->flags, pe_action_runnable)
	&& pcmk_is_set(input->type, pe_order_one_or_more)) {
	crm_trace("Ignoring %s (%d) input %s (%d): "
	"one-or-more and input unrunnable",
	action->uuid, action->id,
	input->action->uuid, input->action->id);
	return false;

	} else if (pcmk_is_set(action->flags, pe_action_pseudo)
	&& pcmk_is_set(input->type, pe_order_stonith_stop)) {
	crm_trace("Ignoring %s (%d) input %s (%d): "
	"stonith stop but action is pseudo",
	action->uuid, action->id,
	input->action->uuid, input->action->id);
	return false;

	} else if (pcmk_is_set(input->type, pe_order_implies_first_migratable)
	&& !pcmk_is_set(input->action->flags, pe_action_runnable)) {
	crm_trace("Ignoring %s (%d) input %s (%d): "
	"implies input migratable but input unrunnable",
	action->uuid, action->id,
	input->action->uuid, input->action->id);
	return false;

	} else if (pcmk_is_set(input->type, pe_order_apply_first_non_migratable)
	&& pcmk_is_set(input->action->flags, pe_action_migrate_runnable)) {
	crm_trace("Ignoring %s (%d) input %s (%d): "
	"only if input unmigratable but input unrunnable",
	action->uuid, action->id,
	input->action->uuid, input->action->id);
	return false;

	} else if ((input->type == pe_order_optional)
	&& pcmk_is_set(input->action->flags, pe_action_migrate_runnable)
	&& pcmk__ends_with(input->action->uuid, "_stop_0")) {
	crm_trace("Ignoring %s (%d) input %s (%d): "
	"optional but stop in migration",
	action->uuid, action->id,
	input->action->uuid, input->action->id);
	return false;

	} else if (input->type == pe_order_load) {
	pe_node_t *input_node = input->action->node;

	// load orderings are relevant only if actions are for same node

	if (action->rsc && pcmk__str_eq(action->task, RSC_MIGRATE, pcmk__str_casei)) {
	pe_node_t *allocated = action->rsc->allocated_to;

	/* For load_stopped -> migrate_to orderings, we care about where it
	* has been allocated to, not where it will be executed.
	*/
	if ((input_node == NULL) \|\| (allocated == NULL)
	\|\| (input_node->details != allocated->details)) {
	crm_trace("Ignoring %s (%d) input %s (%d): "
	"load ordering node mismatch %s vs %s",
	action->uuid, action->id,
	input->action->uuid, input->action->id,
	(allocated? allocated->details->uname : "<none>"),
	(input_node? input_node->details->uname : "<none>"));
	input->type = pe_order_none;
	return false;
	}

	} else if ((input_node == NULL) \|\| (action->node == NULL)
	\|\| (input_node->details != action->node->details)) {
	crm_trace("Ignoring %s (%d) input %s (%d): "
	"load ordering node mismatch %s vs %s",
	action->uuid, action->id,
	input->action->uuid, input->action->id,
	(action->node? action->node->details->uname : "<none>"),
	(input_node? input_node->details->uname : "<none>"));
	input->type = pe_order_none;
	return false;

	} else if (pcmk_is_set(input->action->flags, pe_action_optional)) {
	crm_trace("Ignoring %s (%d) input %s (%d): "
	"load ordering input optional",
	action->uuid, action->id,
	input->action->uuid, input->action->id);
	input->type = pe_order_none;
	return false;
	}

	} else if (input->type == pe_order_anti_colocation) {
	if (input->action->node && action->node
	&& (input->action->node->details != action->node->details)) {
	crm_trace("Ignoring %s (%d) input %s (%d): "
	"anti-colocation node mismatch %s vs %s",
	action->uuid, action->id,
	input->action->uuid, input->action->id,
	action->node->details->uname,
	input->action->node->details->uname);
	input->type = pe_order_none;
	return false;

	} else if (pcmk_is_set(input->action->flags, pe_action_optional)) {
	crm_trace("Ignoring %s (%d) input %s (%d): "
	"anti-colocation input optional",
	action->uuid, action->id,
	input->action->uuid, input->action->id);
	input->type = pe_order_none;
	return false;
	}

	} else if (input->action->rsc
	&& input->action->rsc != action->rsc
	&& pcmk_is_set(input->action->rsc->flags, pe_rsc_failed)
	&& !pcmk_is_set(input->action->rsc->flags, pe_rsc_managed)
	&& pcmk__ends_with(input->action->uuid, "_stop_0")
	&& action->rsc && pe_rsc_is_clone(action->rsc)) {
	crm_warn("Ignoring requirement that %s complete before %s:"
	" unmanaged failed resources cannot prevent clone shutdown",
	input->action->uuid, action->uuid);
	return false;

	} else if (pcmk_is_set(input->action->flags, pe_action_optional)
	&& !pcmk_any_flags_set(input->action->flags,
	pe_action_print_always\|pe_action_dumped)
	&& !should_dump_action(input->action)) {
	crm_trace("Ignoring %s (%d) input %s (%d): "
	"input optional",
	action->uuid, action->id,
	input->action->uuid, input->action->id);
	return false;
	}

	crm_trace("%s (%d) input %s %s (%d) on %s should be dumped: %s %s 0x%.6x",
	action->uuid, action->id, action_type_str(input->action->flags),
	input->action->uuid, input->action->id,
	action_node_str(input->action),
	action_runnable_str(input->action->flags),
	action_optional_str(input->action->flags), input->type);
	return true;
	}

	bool
	pcmk__graph_has_loop(pe_action_t init_action, pe_action_t action,
	pe_action_wrapper_t *input)
	{
	bool has_loop = false;

	if (pcmk_is_set(input->action->flags, pe_action_tracking)) {
	crm_trace("Breaking tracking loop: %s@%s -> %s@%s (0x%.6x)",
	input->action->uuid,
	input->action->node? input->action->node->details->uname : "",
	action->uuid,
	action->node? action->node->details->uname : "",
	input->type);
	return false;
	}

	// Don't need to check inputs that won't be used
	if (!check_dump_input(action, input)) {
	return false;
	}

	if (input->action == init_action) {
	crm_debug("Input loop found in %s@%s ->...-> %s@%s",
	action->uuid,
	action->node? action->node->details->uname : "",
	init_action->uuid,
	init_action->node? init_action->node->details->uname : "");
	return true;
	}

	pe__set_action_flags(input->action, pe_action_tracking);

	crm_trace("Checking inputs of action %s@%s input %s@%s (0x%.6x)"
	"for graph loop with %s@%s ",
	action->uuid,
	action->node? action->node->details->uname : "",
	input->action->uuid,
	input->action->node? input->action->node->details->uname : "",
	input->type,
	init_action->uuid,
	init_action->node? init_action->node->details->uname : "");

	// Recursively check input itself for loops
	for (GList *iter = input->action->actions_before;
	iter != NULL; iter = iter->next) {

	if (pcmk__graph_has_loop(init_action, input->action,
	(pe_action_wrapper_t *) iter->data)) {
	// Recursive call already logged a debug message
	has_loop = true;
	goto done;
	}
	}

	done:
	pe__clear_action_flags(input->action, pe_action_tracking);

	if (!has_loop) {
	crm_trace("No input loop found in %s@%s -> %s@%s (0x%.6x)",
	input->action->uuid,
	input->action->node? input->action->node->details->uname : "",
	action->uuid,
	action->node? action->node->details->uname : "",
	input->type);
	}
	return has_loop;
	}

	// Remove duplicate inputs (regardless of flags)
	static void
	deduplicate_inputs(pe_action_t *action)
	{
	GList *item = NULL;
	GList *next = NULL;
	pe_action_wrapper_t *last_input = NULL;

	action->actions_before = g_list_sort(action->actions_before,
	sort_action_id);
	for (item = action->actions_before; item != NULL; item = next) {
	pe_action_wrapper_t input = (pe_action_wrapper_t ) item->data;

	next = item->next;
	if (last_input && (input->action->id == last_input->action->id)) {
	crm_trace("Input %s (%d) duplicate skipped for action %s (%d)",
	input->action->uuid, input->action->id,
	action->uuid, action->id);

	/* For the purposes of scheduling, the ordering flags no longer
	* matter, but crm_simulate looks at certain ones when creating a
	* dot graph. Combining the flags is sufficient for that purpose.
	*/
	last_input->type \|= input->type;
	if (input->state == pe_link_dumped) {
	last_input->state = pe_link_dumped;
	}

	free(item->data);
	action->actions_before = g_list_delete_link(action->actions_before,
	item);
	} else {
	last_input = input;
	input->state = pe_link_not_dumped;
	}
	}
	}

	/*!
	* \internal
	* \brief Add an action to the transition graph XML if appropriate
	*
	* \param[in] action Action to possibly add
	* \param[in] data_set Cluster working set
	*
	* \note This will de-duplicate the action inputs, meaning that the
	* pe_action_wrapper_t:type flags can no longer be relied on to retain
	* their original settings. That means this MUST be called after
	* pcmk__apply_orderings() is complete, and nothing after this should rely
	* on those type flags. (For example, some code looks for type equal to
	* some flag rather than whether the flag is set, and some code looks for
	* particular combinations of flags -- such code must be done before
	* stage8().)
	*/
	void
	graph_element_from_action(pe_action_t action, pe_working_set_t data_set)
	{
	GList *lpc = NULL;
	int synapse_priority = 0;
	xmlNode *syn = NULL;
	xmlNode *set = NULL;
	xmlNode *in = NULL;
	xmlNode *xml_action = NULL;
	pe_action_wrapper_t *input = NULL;

	/* If we haven't already, de-duplicate inputs -- even if we won't be dumping
	* the action, so that crm_simulate dot graphs don't have duplicates.
	*/
	if (!pcmk_is_set(action->flags, pe_action_dedup)) {
	deduplicate_inputs(action);
	pe__set_action_flags(action, pe_action_dedup);
	}

	if (should_dump_action(action) == FALSE) {
	return;
	}

	pe__set_action_flags(action, pe_action_dumped);

	syn = create_xml_node(data_set->graph, "synapse");
	set = create_xml_node(syn, "action_set");
	in = create_xml_node(syn, "inputs");

	crm_xml_add_int(syn, XML_ATTR_ID, data_set->num_synapse);
	data_set->num_synapse++;

	if (action->rsc != NULL) {
	synapse_priority = action->rsc->priority;
	}
	if (action->priority > synapse_priority) {
	synapse_priority = action->priority;
	}
	if (synapse_priority > 0) {
	crm_xml_add_int(syn, XML_CIB_ATTR_PRIORITY, synapse_priority);
	}

	xml_action = action2xml(action, FALSE, data_set);
	add_node_nocopy(set, crm_element_name(xml_action), xml_action);

	for (lpc = action->actions_before; lpc != NULL; lpc = lpc->next) {
	input = (pe_action_wrapper_t *) lpc->data;
	if (check_dump_input(action, input)) {
	xmlNode *input_xml = create_xml_node(in, "trigger");

	input->state = pe_link_dumped;
	xml_action = action2xml(input->action, TRUE, data_set);
	add_node_nocopy(input_xml, crm_element_name(xml_action), xml_action);
	}
	}
	}
	diff --git a/lib/pacemaker/pcmk_sched_messages.c b/lib/pacemaker/pcmk_sched_messages.c
	index e0666265f4..e5a779a5c9 100644
	--- a/lib/pacemaker/pcmk_sched_messages.c
	+++ b/lib/pacemaker/pcmk_sched_messages.c
	@@ -1,159 +1,159 @@
	/*
	* Copyright 2004-2021 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 <sys/param.h>

	#include <crm/crm.h>
	#include <crm/cib.h>
	#include <crm/msg_xml.h>
	#include <crm/common/xml.h>

	#include <glib.h>

	#include <crm/pengine/status.h>
	#include <pacemaker-internal.h>
	#include <crm/common/ipc_internal.h>
	#include "libpacemaker_private.h"

	extern bool pcmk__is_daemon;

	static void
	log_resource_details(pe_working_set_t *data_set)
	{
	pcmk__output_t *out = data_set->priv;
	GList *all = NULL;

	/* We need a list of nodes that we are allowed to output information for.
	* This is necessary because out->message for all the resource-related
	* messages expects such a list, due to the `crm_mon --node=` feature. Here,
	* we just make it a list of all the nodes.
	*/
	all = g_list_prepend(all, (gpointer) "*");

	for (GList *item = data_set->resources; item != NULL; item = item->next) {
	pe_resource_t rsc = (pe_resource_t ) item->data;

	// Log all resources except inactive orphans
	if (!pcmk_is_set(rsc->flags, pe_rsc_orphan)
	\|\| (rsc->role != RSC_ROLE_STOPPED)) {
	out->message(out, crm_map_element_name(rsc->xml), 0, rsc, all, all);
	}
	}

	g_list_free(all);
	}

	static void
	log_all_actions(pe_working_set_t *data_set)
	{
	/* This only ever outputs to the log, so ignore whatever output object was
	* previously set and just log instead.
	*/
	pcmk__output_t *prev_out = data_set->priv;
	pcmk__output_t *out = pcmk__new_logger();

	if (out == NULL) {
	return;
	}

	pcmk__output_set_log_level(out, LOG_NOTICE);
	data_set->priv = out;

	out->begin_list(out, NULL, NULL, "Actions");
	LogNodeActions(data_set);

	g_list_foreach(data_set->resources, (GFunc) LogActions, data_set);

	out->end_list(out);
	out->finish(out, CRM_EX_OK, true, NULL);
	pcmk__output_free(out);

	data_set->priv = prev_out;
	}

	/*!
	* \internal
	* \brief Run the scheduler for a given CIB
	*
	* \param[in,out] data_set Cluster working set
	* \param[in] xml_input CIB XML to use as scheduler input
	* \param[in] now Time to use for rule evaluation (or NULL for now)
	*/
	xmlNode *
	pcmk__schedule_actions(pe_working_set_t data_set, xmlNode xml_input,
	crm_time_t *now)
	{
	GList *gIter = NULL;

	CRM_ASSERT(xml_input \|\| pcmk_is_set(data_set->flags, pe_flag_have_status));

	if (!pcmk_is_set(data_set->flags, pe_flag_have_status)) {
	set_working_set_defaults(data_set);
	data_set->input = xml_input;
	data_set->now = now;

	} else {
	crm_trace("Already have status - reusing");
	}

	if (data_set->now == NULL) {
	data_set->now = crm_time_new(NULL);
	}

	crm_trace("Calculate cluster status");
	stage0(data_set);
	if (!pcmk_is_set(data_set->flags, pe_flag_quick_location) &&
	pcmk__is_daemon) {
	log_resource_details(data_set);
	}

	crm_trace("Applying location constraints");
	stage2(data_set);

	if (pcmk_is_set(data_set->flags, pe_flag_quick_location)) {
	return NULL;
	}

	pcmk__create_internal_constraints(data_set);

	crm_trace("Check actions");
	stage4(data_set);

	crm_trace("Allocate resources");
	stage5(data_set);

	crm_trace("Processing fencing and shutdown cases");
	stage6(data_set);

	pcmk__apply_orderings(data_set);
	log_all_actions(data_set);

	crm_trace("Create transition graph");
	stage8(data_set);

	crm_trace("=#=#=#=#= Summary =#=#=#=#=");
	crm_trace("\t========= Set %d (Un-runnable) =========", -1);
	if (get_crm_log_level() == LOG_TRACE) {
	gIter = data_set->actions;
	for (; gIter != NULL; gIter = gIter->next) {
	pe_action_t action = (pe_action_t ) gIter->data;

	if (!pcmk_any_flags_set(action->flags,
	pe_action_optional
	\|pe_action_runnable
	\|pe_action_pseudo)) {
	- log_action(LOG_TRACE, "\t", action, TRUE);
	+ log_action("\t", action, TRUE);
	}
	}
	}

	return data_set->graph;
	}
	diff --git a/lib/pacemaker/pcmk_sched_utils.c b/lib/pacemaker/pcmk_sched_utils.c
	index 5935899ddb..a175eaabd4 100644
	--- a/lib/pacemaker/pcmk_sched_utils.c
	+++ b/lib/pacemaker/pcmk_sched_utils.c
	@@ -1,617 +1,617 @@
	/*
	* Copyright 2004-2021 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 <crm/msg_xml.h>
	#include <crm/lrmd.h> // lrmd_event_data_t
	#include <crm/common/xml_internal.h>
	#include <crm/lrmd_internal.h>
	#include <pacemaker-internal.h>
	#include <pacemaker.h>
	#include "libpacemaker_private.h"

	gboolean
	can_run_resources(const pe_node_t * node)
	{
	if (node == NULL) {
	return FALSE;
	}
	#if 0
	if (node->weight < 0) {
	return FALSE;
	}
	#endif

	if (node->details->online == FALSE
	\|\| node->details->shutdown \|\| node->details->unclean
	\|\| node->details->standby \|\| node->details->maintenance) {
	crm_trace("%s: online=%d, unclean=%d, standby=%d, maintenance=%d",
	node->details->uname, node->details->online,
	node->details->unclean, node->details->standby, node->details->maintenance);
	return FALSE;
	}
	return TRUE;
	}

	/*!
	* \internal
	* \brief Copy a hash table of node objects
	*
	* \param[in] nodes Hash table to copy
	*
	* \return New copy of nodes (or NULL if nodes is NULL)
	*/
	GHashTable *
	pcmk__copy_node_table(GHashTable *nodes)
	{
	GHashTable *new_table = NULL;
	GHashTableIter iter;
	pe_node_t *node = NULL;

	if (nodes == NULL) {
	return NULL;
	}
	new_table = pcmk__strkey_table(NULL, free);
	g_hash_table_iter_init(&iter, nodes);
	while (g_hash_table_iter_next(&iter, NULL, (gpointer *) &node)) {
	pe_node_t *new_node = pe__copy_node(node);

	g_hash_table_insert(new_table, (gpointer) new_node->details->id,
	new_node);
	}
	return new_table;
	}

	/*!
	* \internal
	* \brief Copy a list of node objects
	*
	* \param[in] list List to copy
	* \param[in] reset Set copies' scores to 0
	*
	* \return New list of shallow copies of nodes in original list
	*/
	GList *
	pcmk__copy_node_list(const GList *list, bool reset)
	{
	GList *result = NULL;

	for (const GList *gIter = list; gIter != NULL; gIter = gIter->next) {
	pe_node_t *new_node = NULL;
	pe_node_t this_node = (pe_node_t ) gIter->data;

	new_node = pe__copy_node(this_node);
	if (reset) {
	new_node->weight = 0;
	}
	result = g_list_prepend(result, new_node);
	}
	return result;
	}

	struct node_weight_s {
	pe_node_t *active;
	pe_working_set_t *data_set;
	};

	/* return -1 if 'a' is more preferred
	* return 1 if 'b' is more preferred
	*/

	static gint
	sort_node_weight(gconstpointer a, gconstpointer b, gpointer data)
	{
	const pe_node_t node1 = (const pe_node_t )a;
	const pe_node_t node2 = (const pe_node_t )b;
	struct node_weight_s *nw = data;

	int node1_weight = 0;
	int node2_weight = 0;

	int result = 0;

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

	node1_weight = node1->weight;
	node2_weight = node2->weight;

	if (can_run_resources(node1) == FALSE) {
	node1_weight = -INFINITY;
	}
	if (can_run_resources(node2) == FALSE) {
	node2_weight = -INFINITY;
	}

	if (node1_weight > node2_weight) {
	crm_trace("%s (%d) > %s (%d) : weight",
	node1->details->uname, node1_weight, node2->details->uname, node2_weight);
	return -1;
	}

	if (node1_weight < node2_weight) {
	crm_trace("%s (%d) < %s (%d) : weight",
	node1->details->uname, node1_weight, node2->details->uname, node2_weight);
	return 1;
	}

	crm_trace("%s (%d) == %s (%d) : weight",
	node1->details->uname, node1_weight, node2->details->uname, node2_weight);

	if (pcmk__str_eq(nw->data_set->placement_strategy, "minimal", pcmk__str_casei)) {
	goto equal;
	}

	if (pcmk__str_eq(nw->data_set->placement_strategy, "balanced", pcmk__str_casei)) {
	result = compare_capacity(node1, node2);
	if (result < 0) {
	crm_trace("%s > %s : capacity (%d)",
	node1->details->uname, node2->details->uname, result);
	return -1;
	} else if (result > 0) {
	crm_trace("%s < %s : capacity (%d)",
	node1->details->uname, node2->details->uname, result);
	return 1;
	}
	}

	/* now try to balance resources across the cluster */
	if (node1->details->num_resources < node2->details->num_resources) {
	crm_trace("%s (%d) > %s (%d) : resources",
	node1->details->uname, node1->details->num_resources,
	node2->details->uname, node2->details->num_resources);
	return -1;

	} else if (node1->details->num_resources > node2->details->num_resources) {
	crm_trace("%s (%d) < %s (%d) : resources",
	node1->details->uname, node1->details->num_resources,
	node2->details->uname, node2->details->num_resources);
	return 1;
	}

	if (nw->active && nw->active->details == node1->details) {
	crm_trace("%s (%d) > %s (%d) : active",
	node1->details->uname, node1->details->num_resources,
	node2->details->uname, node2->details->num_resources);
	return -1;
	} else if (nw->active && nw->active->details == node2->details) {
	crm_trace("%s (%d) < %s (%d) : active",
	node1->details->uname, node1->details->num_resources,
	node2->details->uname, node2->details->num_resources);
	return 1;
	}
	equal:
	crm_trace("%s = %s", node1->details->uname, node2->details->uname);
	return strcmp(node1->details->uname, node2->details->uname);
	}

	GList *
	sort_nodes_by_weight(GList nodes, pe_node_t active_node,
	pe_working_set_t *data_set)
	{
	struct node_weight_s nw = { active_node, data_set };

	return g_list_sort_with_data(nodes, sort_node_weight, &nw);
	}

	void
	-log_action(unsigned int log_level, const char pre_text, pe_action_t action, gboolean details)
	+log_action(const char pre_text, pe_action_t action, gboolean details)
	{
	const char *node_uname = NULL;
	const char *node_uuid = NULL;
	const char *desc = NULL;

	if (action == NULL) {
	crm_trace("%s%s: <NULL>", pre_text == NULL ? "" : pre_text, pre_text == NULL ? "" : ": ");
	return;
	}

	if (pcmk_is_set(action->flags, pe_action_pseudo)) {
	node_uname = NULL;
	node_uuid = NULL;

	} else if (action->node != NULL) {
	node_uname = action->node->details->uname;
	node_uuid = action->node->details->id;
	} else {
	node_uname = "<none>";
	node_uuid = NULL;
	}

	switch (text2task(action->task)) {
	case stonith_node:
	case shutdown_crm:
	if (pcmk_is_set(action->flags, pe_action_pseudo)) {
	desc = "Pseudo ";
	} else if (pcmk_is_set(action->flags, pe_action_optional)) {
	desc = "Optional ";
	} else if (!pcmk_is_set(action->flags, pe_action_runnable)) {
	desc = "!!Non-Startable!! ";
	} else if (pcmk_is_set(action->flags, pe_action_processed)) {
	desc = "";
	} else {
	desc = "(Provisional) ";
	}
	crm_trace("%s%s%sAction %d: %s%s%s%s%s%s",
	((pre_text == NULL)? "" : pre_text),
	((pre_text == NULL)? "" : ": "),
	desc, action->id, action->uuid,
	(node_uname? "\ton " : ""), (node_uname? node_uname : ""),
	(node_uuid? "\t\t(" : ""), (node_uuid? node_uuid : ""),
	(node_uuid? ")" : ""));
	break;
	default:
	if (pcmk_is_set(action->flags, pe_action_optional)) {
	desc = "Optional ";
	} else if (pcmk_is_set(action->flags, pe_action_pseudo)) {
	desc = "Pseudo ";
	} else if (!pcmk_is_set(action->flags, pe_action_runnable)) {
	desc = "!!Non-Startable!! ";
	} else if (pcmk_is_set(action->flags, pe_action_processed)) {
	desc = "";
	} else {
	desc = "(Provisional) ";
	}
	crm_trace("%s%s%sAction %d: %s %s%s%s%s%s%s",
	((pre_text == NULL)? "" : pre_text),
	((pre_text == NULL)? "" : ": "),
	desc, action->id, action->uuid,
	(action->rsc? action->rsc->id : "<none>"),
	(node_uname? "\ton " : ""), (node_uname? node_uname : ""),
	(node_uuid? "\t\t(" : ""), (node_uuid? node_uuid : ""),
	(node_uuid? ")" : ""));
	break;
	}

	if (details) {
	GList *gIter = NULL;

	crm_trace("\t\t====== Preceding Actions");

	gIter = action->actions_before;
	for (; gIter != NULL; gIter = gIter->next) {
	pe_action_wrapper_t other = (pe_action_wrapper_t ) gIter->data;

	- log_action(log_level + 1, "\t\t", other->action, FALSE);
	+ log_action("\t\t", other->action, FALSE);
	}

	crm_trace("\t\t====== Subsequent Actions");

	gIter = action->actions_after;
	for (; gIter != NULL; gIter = gIter->next) {
	pe_action_wrapper_t other = (pe_action_wrapper_t ) gIter->data;

	- log_action(log_level + 1, "\t\t", other->action, FALSE);
	+ log_action("\t\t", other->action, FALSE);
	}

	crm_trace("\t\t====== End");

	} else {
	crm_trace("\t\t(before=%d, after=%d)",
	g_list_length(action->actions_before), g_list_length(action->actions_after));
	}
	}

	gboolean
	can_run_any(GHashTable * nodes)
	{
	GHashTableIter iter;
	pe_node_t *node = NULL;

	if (nodes == NULL) {
	return FALSE;
	}

	g_hash_table_iter_init(&iter, nodes);
	while (g_hash_table_iter_next(&iter, NULL, (void **)&node)) {
	if (can_run_resources(node) && node->weight >= 0) {
	return TRUE;
	}
	}

	return FALSE;
	}

	pe_action_t *
	create_pseudo_resource_op(pe_resource_t * rsc, const char task, bool optional, bool runnable, pe_working_set_t data_set)
	{
	pe_action_t *action = custom_action(rsc, pcmk__op_key(rsc->id, task, 0),
	task, NULL, optional, TRUE, data_set);

	pe__set_action_flags(action, pe_action_pseudo);
	if(runnable) {
	pe__set_action_flags(action, pe_action_runnable);
	}
	return action;
	}

	/*!
	* \internal
	* \brief Create an executor cancel op
	*
	* \param[in] rsc Resource of action to cancel
	* \param[in] task Name of action to cancel
	* \param[in] interval_ms Interval of action to cancel
	* \param[in] node Node of action to cancel
	* \param[in] data_set Working set of cluster
	*
	* \return Created op
	*/
	pe_action_t *
	pe_cancel_op(pe_resource_t rsc, const char task, guint interval_ms,
	pe_node_t node, pe_working_set_t data_set)
	{
	pe_action_t *cancel_op;
	char *interval_ms_s = crm_strdup_printf("%u", interval_ms);

	// @TODO dangerous if possible to schedule another action with this key
	char *key = pcmk__op_key(rsc->id, task, interval_ms);

	cancel_op = custom_action(rsc, key, RSC_CANCEL, node, FALSE, TRUE,
	data_set);

	free(cancel_op->task);
	cancel_op->task = strdup(RSC_CANCEL);

	free(cancel_op->cancel_task);
	cancel_op->cancel_task = strdup(task);

	add_hash_param(cancel_op->meta, XML_LRM_ATTR_TASK, task);
	add_hash_param(cancel_op->meta, XML_LRM_ATTR_INTERVAL_MS, interval_ms_s);
	free(interval_ms_s);

	return cancel_op;
	}

	/*!
	* \internal
	* \brief Create a shutdown op for a scheduler transition
	*
	* \param[in] node Node being shut down
	* \param[in] data_set Working set of cluster
	*
	* \return Created op
	*/
	pe_action_t *
	sched_shutdown_op(pe_node_t node, pe_working_set_t data_set)
	{
	char *shutdown_id = crm_strdup_printf("%s-%s", CRM_OP_SHUTDOWN,
	node->details->uname);

	pe_action_t *shutdown_op = custom_action(NULL, shutdown_id, CRM_OP_SHUTDOWN,
	node, FALSE, TRUE, data_set);

	pcmk__order_stops_before_shutdown(node, shutdown_op, data_set);
	add_hash_param(shutdown_op->meta, XML_ATTR_TE_NOWAIT, XML_BOOLEAN_TRUE);
	return shutdown_op;
	}

	static char *
	generate_transition_magic(const char *transition_key, int op_status, int op_rc)
	{
	CRM_CHECK(transition_key != NULL, return NULL);
	return crm_strdup_printf("%d:%d;%s", op_status, op_rc, transition_key);
	}

	static void
	append_digest(lrmd_event_data_t op, xmlNode update, const char *version,
	const char *magic, int level)
	{
	/* this will enable us to later determine that the
	* resource's parameters have changed and we should force
	* a restart
	*/
	char *digest = NULL;
	xmlNode *args_xml = NULL;

	if (op->params == NULL) {
	return;
	}

	args_xml = create_xml_node(NULL, XML_TAG_PARAMS);
	g_hash_table_foreach(op->params, hash2field, args_xml);
	pcmk__filter_op_for_digest(args_xml);
	digest = calculate_operation_digest(args_xml, version);

	#if 0
	if (level < get_crm_log_level()
	&& op->interval_ms == 0 && pcmk__str_eq(op->op_type, CRMD_ACTION_START, pcmk__str_none)) {
	char *digest_source = dump_xml_unformatted(args_xml);

	do_crm_log(level, "Calculated digest %s for %s (%s). Source: %s",
	digest, ID(update), magic, digest_source);
	free(digest_source);
	}
	#endif
	crm_xml_add(update, XML_LRM_ATTR_OP_DIGEST, digest);

	free_xml(args_xml);
	free(digest);
	}

	#define FAKE_TE_ID "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"

	/*!
	* \internal
	* \brief Create XML for resource operation history update
	*
	* \param[in,out] parent Parent XML node to add to
	* \param[in,out] op Operation event data
	* \param[in] caller_version DC feature set
	* \param[in] target_rc Expected result of operation
	* \param[in] node Name of node on which operation was performed
	* \param[in] origin Arbitrary description of update source
	* \param[in] level A log message will be logged at this level
	*
	* \return Newly created XML node for history update
	*/
	xmlNode *
	pcmk__create_history_xml(xmlNode parent, lrmd_event_data_t op,
	const char *caller_version, int target_rc,
	const char node, const char origin, int level)
	{
	char *key = NULL;
	char *magic = NULL;
	char *op_id = NULL;
	char *op_id_additional = NULL;
	char *local_user_data = NULL;
	const char *exit_reason = NULL;

	xmlNode *xml_op = NULL;
	const char *task = NULL;

	CRM_CHECK(op != NULL, return NULL);
	do_crm_log(level, "%s: Updating resource %s after %s op %s (interval=%u)",
	origin, op->rsc_id, op->op_type,
	pcmk_exec_status_str(op->op_status), op->interval_ms);

	crm_trace("DC version: %s", caller_version);

	task = op->op_type;

	/* Record a successful agent reload as a start, and a failed one as a
	* monitor, to make life easier for the scheduler when determining the
	* current state.
	*
	* @COMPAT We should check "reload" here only if the operation was for a
	* pre-OCF-1.1 resource agent, but we don't know that here, and we should
	* only ever get results for actions scheduled by us, so we can reasonably
	* assume any "reload" is actually a pre-1.1 agent reload.
	*/
	if (pcmk__str_any_of(task, CRMD_ACTION_RELOAD, CRMD_ACTION_RELOAD_AGENT,
	NULL)) {
	if (op->op_status == PCMK_EXEC_DONE) {
	task = CRMD_ACTION_START;
	} else {
	task = CRMD_ACTION_STATUS;
	}
	}

	key = pcmk__op_key(op->rsc_id, task, op->interval_ms);
	if (pcmk__str_eq(task, CRMD_ACTION_NOTIFY, pcmk__str_none)) {
	const char *n_type = crm_meta_value(op->params, "notify_type");
	const char *n_task = crm_meta_value(op->params, "notify_operation");

	CRM_LOG_ASSERT(n_type != NULL);
	CRM_LOG_ASSERT(n_task != NULL);
	op_id = pcmk__notify_key(op->rsc_id, n_type, n_task);

	if (op->op_status != PCMK_EXEC_PENDING) {
	/* Ignore notify errors.
	*
	* @TODO It might be better to keep the correct result here, and
	* ignore it in process_graph_event().
	*/
	lrmd__set_result(op, PCMK_OCF_OK, PCMK_EXEC_DONE, NULL);
	}

	} else if (did_rsc_op_fail(op, target_rc)) {
	op_id = pcmk__op_key(op->rsc_id, "last_failure", 0);
	if (op->interval_ms == 0) {
	// Ensure 'last' gets updated, in case record-pending is true
	op_id_additional = pcmk__op_key(op->rsc_id, "last", 0);
	}
	exit_reason = op->exit_reason;

	} else if (op->interval_ms > 0) {
	op_id = strdup(key);

	} else {
	op_id = pcmk__op_key(op->rsc_id, "last", 0);
	}

	again:
	xml_op = pcmk__xe_match(parent, XML_LRM_TAG_RSC_OP, XML_ATTR_ID, op_id);
	if (xml_op == NULL) {
	xml_op = create_xml_node(parent, XML_LRM_TAG_RSC_OP);
	}

	if (op->user_data == NULL) {
	crm_debug("Generating fake transition key for: " PCMK__OP_FMT
	" %d from %s", op->rsc_id, op->op_type, op->interval_ms,
	op->call_id, origin);
	local_user_data = pcmk__transition_key(-1, op->call_id, target_rc,
	FAKE_TE_ID);
	op->user_data = local_user_data;
	}

	if(magic == NULL) {
	magic = generate_transition_magic(op->user_data, op->op_status, op->rc);
	}

	crm_xml_add(xml_op, XML_ATTR_ID, op_id);
	crm_xml_add(xml_op, XML_LRM_ATTR_TASK_KEY, key);
	crm_xml_add(xml_op, XML_LRM_ATTR_TASK, task);
	crm_xml_add(xml_op, XML_ATTR_ORIGIN, origin);
	crm_xml_add(xml_op, XML_ATTR_CRM_VERSION, caller_version);
	crm_xml_add(xml_op, XML_ATTR_TRANSITION_KEY, op->user_data);
	crm_xml_add(xml_op, XML_ATTR_TRANSITION_MAGIC, magic);
	crm_xml_add(xml_op, XML_LRM_ATTR_EXIT_REASON, exit_reason == NULL ? "" : exit_reason);
	crm_xml_add(xml_op, XML_LRM_ATTR_TARGET, node); /* For context during triage */

	crm_xml_add_int(xml_op, XML_LRM_ATTR_CALLID, op->call_id);
	crm_xml_add_int(xml_op, XML_LRM_ATTR_RC, op->rc);
	crm_xml_add_int(xml_op, XML_LRM_ATTR_OPSTATUS, op->op_status);
	crm_xml_add_ms(xml_op, XML_LRM_ATTR_INTERVAL_MS, op->interval_ms);

	if (compare_version("2.1", caller_version) <= 0) {
	if (op->t_run \|\| op->t_rcchange \|\| op->exec_time \|\| op->queue_time) {
	crm_trace("Timing data (" PCMK__OP_FMT
	"): last=%u change=%u exec=%u queue=%u",
	op->rsc_id, op->op_type, op->interval_ms,
	op->t_run, op->t_rcchange, op->exec_time, op->queue_time);

	if ((op->interval_ms != 0) && (op->t_rcchange != 0)) {
	// Recurring ops may have changed rc after initial run
	crm_xml_add_ll(xml_op, XML_RSC_OP_LAST_CHANGE,
	(long long) op->t_rcchange);
	} else {
	crm_xml_add_ll(xml_op, XML_RSC_OP_LAST_CHANGE,
	(long long) op->t_run);
	}

	crm_xml_add_int(xml_op, XML_RSC_OP_T_EXEC, op->exec_time);
	crm_xml_add_int(xml_op, XML_RSC_OP_T_QUEUE, op->queue_time);
	}
	}

	if (pcmk__str_any_of(op->op_type, CRMD_ACTION_MIGRATE, CRMD_ACTION_MIGRATED, NULL)) {
	/*
	* Record migrate_source and migrate_target always for migrate ops.
	*/
	const char *name = XML_LRM_ATTR_MIGRATE_SOURCE;

	crm_xml_add(xml_op, name, crm_meta_value(op->params, name));

	name = XML_LRM_ATTR_MIGRATE_TARGET;
	crm_xml_add(xml_op, name, crm_meta_value(op->params, name));
	}

	append_digest(op, xml_op, caller_version, magic, LOG_DEBUG);

	if (op_id_additional) {
	free(op_id);
	op_id = op_id_additional;
	op_id_additional = NULL;
	goto again;
	}

	if (local_user_data) {
	free(local_user_data);
	op->user_data = NULL;
	}
	free(magic);
	free(op_id);
	free(key);
	return xml_op;
	}

File Metadata

Mime Type: text/x-diff
Expires: Thu, Oct 16, 12:15 AM (1 d, 15 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 2522313
Default Alt Text: (67 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions