No OneTemporary
Actions

Size

391 KB

Referenced Files

None

Subscribers

None

View Options

This file is larger than 256 KB, so syntax highlighting was skipped.

	diff --git a/include/crm/common/tickets_internal.h b/include/crm/common/tickets_internal.h
	index 0b945aa744..e57e2b7423 100644
	--- a/include/crm/common/tickets_internal.h
	+++ b/include/crm/common/tickets_internal.h
	@@ -1,39 +1,71 @@
	/*
	* Copyright 2004-2024 the Pacemaker project contributors
	*
	* The version control history for this file may have further details.
	*
	* This source code is licensed under the GNU Lesser General Public License
	* version 2.1 or later (LGPLv2.1+) WITHOUT ANY WARRANTY.
	*/

	#ifndef PCMK__CRM_COMMON_TICKETS_INTERNAL__H
	#define PCMK__CRM_COMMON_TICKETS_INTERNAL__H

	+#include <stdint.h> // uint32_t, UINT32_C()
	#include <sys/types.h> // time_t
	-#include <glib.h> // gboolean, GHashTable
	+#include <glib.h> // GHashTable

	#ifdef __cplusplus
	extern "C" {
	#endif

	/*!
	* \file
	* \brief Scheduler API for tickets
	* \ingroup core
	*/

	+/*!
	+ * \internal
	+ * \brief Set ticket flags
	+ *
	+ * \param[in,out] ticket Ticket to set flags for
	+ * \param[in] flags_to_set Group of enum pcmk__ticket_flags to set
	+ */
	+#define pcmk__set_ticket_flags(ticket, flags_to_set) do { \
	+ (ticket)->flags = pcmk__set_flags_as(__func__, __LINE__, \
	+ LOG_TRACE, "Ticket", (ticket)->id, (ticket)->flags, \
	+ (flags_to_set), #flags_to_set); \
	+ } while (0)
	+
	+/*!
	+ * \internal
	+ * \brief Clear ticket flags
	+ *
	+ * \param[in,out] ticket Ticket to clear flags for
	+ * \param[in] flags_to_clear Group of enum pcmk__ticket_flags to clear
	+ */
	+#define pcmk__clear_ticket_flags(ticket, flags_to_clear) do { \
	+ (ticket)->flags = pcmk__clear_flags_as(__func__, __LINE__, \
	+ LOG_TRACE, "Ticket", (ticket)->id, (ticket)->flags, \
	+ (flags_to_clear), #flags_to_clear); \
	+ } while (0)
	+
	+enum pcmk__ticket_flags {
	+ pcmk__ticket_none = UINT32_C(0),
	+ pcmk__ticket_granted = (UINT32_C(1) << 0),
	+ pcmk__ticket_standby = (UINT32_C(1) << 1),
	+};
	+
	// Ticket constraint object
	typedef struct {
	char *id; // XML ID of ticket constraint or state
	- gboolean granted; // Whether cluster has been granted the ticket
	- time_t last_granted; // When cluster was last granted the ticket
	- gboolean standby; // Whether ticket is temporarily suspended
	GHashTable *state; // XML attributes from ticket state
	+ time_t last_granted; // When cluster was last granted the ticket
	+ uint32_t flags; // Group of enum pcmk__ticket_flags
	} pcmk__ticket_t;

	#ifdef __cplusplus
	}
	#endif

	#endif // PCMK__CRM_COMMON_TICKETS_INTERNAL__H
	diff --git a/lib/pacemaker/pcmk_sched_tickets.c b/lib/pacemaker/pcmk_sched_tickets.c
	index 6888676553..061ec1e0b9 100644
	--- a/lib/pacemaker/pcmk_sched_tickets.c
	+++ b/lib/pacemaker/pcmk_sched_tickets.c
	@@ -1,545 +1,550 @@
	/*
	* Copyright 2004-2024 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/common/scheduler_internal.h>
	#include <crm/pengine/status.h>
	#include <pacemaker-internal.h>

	#include "libpacemaker_private.h"

	enum loss_ticket_policy {
	loss_ticket_stop,
	loss_ticket_demote,
	loss_ticket_fence,
	loss_ticket_freeze
	};

	typedef struct {
	const char *id;
	pcmk_resource_t *rsc;
	pcmk__ticket_t *ticket;
	enum loss_ticket_policy loss_policy;
	int role;
	} rsc_ticket_t;

	/*!
	* \brief Check whether a ticket constraint matches a resource by role
	*
	* \param[in] rsc_ticket Ticket constraint
	* \param[in] rsc Resource to compare with ticket
	*
	* \param[in] true if constraint has no role or resource's role matches
	* constraint's, otherwise false
	*/
	static bool
	ticket_role_matches(const pcmk_resource_t rsc, const rsc_ticket_t rsc_ticket)
	{
	if ((rsc_ticket->role == pcmk_role_unknown)
	\|\| (rsc_ticket->role == rsc->private->orig_role)) {
	return true;
	}
	pcmk__rsc_trace(rsc, "Skipping constraint: \"%s\" state filter",
	pcmk_role_text(rsc_ticket->role));
	return false;
	}

	/*!
	* \brief Create location constraints and fencing as needed for a ticket
	*
	* \param[in,out] rsc Resource affected by ticket
	* \param[in] rsc_ticket Ticket
	*/
	static void
	constraints_for_ticket(pcmk_resource_t rsc, const rsc_ticket_t rsc_ticket)
	{
	GList *iter = NULL;

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

	- if (rsc_ticket->ticket->granted && !rsc_ticket->ticket->standby) {
	+ if (pcmk_is_set(rsc_ticket->ticket->flags, pcmk__ticket_granted)
	+ && !pcmk_is_set(rsc_ticket->ticket->flags, pcmk__ticket_standby)) {
	return;
	}

	if (rsc->private->children != NULL) {
	pcmk__rsc_trace(rsc, "Processing ticket dependencies from %s", rsc->id);
	for (iter = rsc->private->children; iter != NULL; iter = iter->next) {
	constraints_for_ticket((pcmk_resource_t *) iter->data, rsc_ticket);
	}
	return;
	}

	pcmk__rsc_trace(rsc, "%s: Processing ticket dependency on %s (%s, %s)",
	rsc->id, rsc_ticket->ticket->id, rsc_ticket->id,
	pcmk_role_text(rsc_ticket->role));

	- if (!rsc_ticket->ticket->granted && (rsc->private->active_nodes != NULL)) {
	+ if (!pcmk_is_set(rsc_ticket->ticket->flags, pcmk__ticket_granted)
	+ && (rsc->private->active_nodes != NULL)) {

	switch (rsc_ticket->loss_policy) {
	case loss_ticket_stop:
	resource_location(rsc, NULL, -PCMK_SCORE_INFINITY,
	"__loss_of_ticket__",
	rsc->private->scheduler);
	break;

	case loss_ticket_demote:
	// Promotion score will be set to -INFINITY in promotion_order()
	if (rsc_ticket->role != pcmk_role_promoted) {
	resource_location(rsc, NULL, -PCMK_SCORE_INFINITY,
	"__loss_of_ticket__",
	rsc->private->scheduler);
	}
	break;

	case loss_ticket_fence:
	if (!ticket_role_matches(rsc, rsc_ticket)) {
	return;
	}

	resource_location(rsc, NULL, -PCMK_SCORE_INFINITY,
	"__loss_of_ticket__",
	rsc->private->scheduler);

	for (iter = rsc->private->active_nodes;
	iter != NULL; iter = iter->next) {

	pe_fence_node(rsc->private->scheduler,
	(pcmk_node_t *) iter->data,
	"deadman ticket was lost", FALSE);
	}
	break;

	case loss_ticket_freeze:
	if (!ticket_role_matches(rsc, rsc_ticket)) {
	return;
	}
	if (rsc->private->active_nodes != NULL) {
	pcmk__clear_rsc_flags(rsc, pcmk__rsc_managed);
	pcmk__set_rsc_flags(rsc, pcmk__rsc_blocked);
	}
	break;
	}

	- } else if (!rsc_ticket->ticket->granted) {
	+ } else if (!pcmk_is_set(rsc_ticket->ticket->flags, pcmk__ticket_granted)) {

	if ((rsc_ticket->role != pcmk_role_promoted)
	\|\| (rsc_ticket->loss_policy == loss_ticket_stop)) {
	resource_location(rsc, NULL, -PCMK_SCORE_INFINITY,
	"__no_ticket__", rsc->private->scheduler);
	}

	- } else if (rsc_ticket->ticket->standby) {
	+ } else if (pcmk_is_set(rsc_ticket->ticket->flags, pcmk__ticket_standby)) {

	if ((rsc_ticket->role != pcmk_role_promoted)
	\|\| (rsc_ticket->loss_policy == loss_ticket_stop)) {
	resource_location(rsc, NULL, -PCMK_SCORE_INFINITY,
	"__ticket_standby__", rsc->private->scheduler);
	}
	}
	}

	static void
	rsc_ticket_new(const char id, pcmk_resource_t rsc, pcmk__ticket_t *ticket,
	const char state, const char loss_policy)
	{
	rsc_ticket_t *new_rsc_ticket = NULL;

	if (rsc == NULL) {
	pcmk__config_err("Ignoring ticket '%s' because resource "
	"does not exist", id);
	return;
	}

	new_rsc_ticket = calloc(1, sizeof(rsc_ticket_t));
	if (new_rsc_ticket == NULL) {
	return;
	}

	if (pcmk__str_eq(state, PCMK_ROLE_STARTED,
	pcmk__str_null_matches\|pcmk__str_casei)) {
	state = PCMK__ROLE_UNKNOWN;
	}

	new_rsc_ticket->id = id;
	new_rsc_ticket->ticket = ticket;
	new_rsc_ticket->rsc = rsc;
	new_rsc_ticket->role = pcmk_parse_role(state);

	if (pcmk__str_eq(loss_policy, PCMK_VALUE_FENCE, pcmk__str_casei)) {
	if (pcmk_is_set(rsc->private->scheduler->flags,
	pcmk_sched_fencing_enabled)) {
	new_rsc_ticket->loss_policy = loss_ticket_fence;
	} else {
	pcmk__config_err("Resetting '" PCMK_XA_LOSS_POLICY "' "
	"for ticket '%s' to '" PCMK_VALUE_STOP "' "
	"because fencing is not configured", ticket->id);
	loss_policy = PCMK_VALUE_STOP;
	}
	}

	if (new_rsc_ticket->loss_policy == loss_ticket_fence) {
	crm_debug("On loss of ticket '%s': Fence the nodes running %s (%s)",
	new_rsc_ticket->ticket->id, new_rsc_ticket->rsc->id,
	pcmk_role_text(new_rsc_ticket->role));

	} else if (pcmk__str_eq(loss_policy, PCMK_VALUE_FREEZE, pcmk__str_casei)) {
	crm_debug("On loss of ticket '%s': Freeze %s (%s)",
	new_rsc_ticket->ticket->id, new_rsc_ticket->rsc->id,
	pcmk_role_text(new_rsc_ticket->role));
	new_rsc_ticket->loss_policy = loss_ticket_freeze;

	} else if (pcmk__str_eq(loss_policy, PCMK_VALUE_DEMOTE, pcmk__str_casei)) {
	crm_debug("On loss of ticket '%s': Demote %s (%s)",
	new_rsc_ticket->ticket->id, new_rsc_ticket->rsc->id,
	pcmk_role_text(new_rsc_ticket->role));
	new_rsc_ticket->loss_policy = loss_ticket_demote;

	} else if (pcmk__str_eq(loss_policy, PCMK_VALUE_STOP, pcmk__str_casei)) {
	crm_debug("On loss of ticket '%s': Stop %s (%s)",
	new_rsc_ticket->ticket->id, new_rsc_ticket->rsc->id,
	pcmk_role_text(new_rsc_ticket->role));
	new_rsc_ticket->loss_policy = loss_ticket_stop;

	} else {
	if (new_rsc_ticket->role == pcmk_role_promoted) {
	crm_debug("On loss of ticket '%s': Default to demote %s (%s)",
	new_rsc_ticket->ticket->id, new_rsc_ticket->rsc->id,
	pcmk_role_text(new_rsc_ticket->role));
	new_rsc_ticket->loss_policy = loss_ticket_demote;

	} else {
	crm_debug("On loss of ticket '%s': Default to stop %s (%s)",
	new_rsc_ticket->ticket->id, new_rsc_ticket->rsc->id,
	pcmk_role_text(new_rsc_ticket->role));
	new_rsc_ticket->loss_policy = loss_ticket_stop;
	}
	}

	pcmk__rsc_trace(rsc, "%s (%s) ==> %s",
	rsc->id, pcmk_role_text(new_rsc_ticket->role), ticket->id);

	rsc->private->ticket_constraints =
	g_list_append(rsc->private->ticket_constraints, new_rsc_ticket);

	rsc->private->scheduler->ticket_constraints =
	g_list_append(rsc->private->scheduler->ticket_constraints,
	new_rsc_ticket);

	- if (!(new_rsc_ticket->ticket->granted) \|\| new_rsc_ticket->ticket->standby) {
	+ if (!pcmk_is_set(new_rsc_ticket->ticket->flags, pcmk__ticket_granted)
	+ \|\| pcmk_is_set(new_rsc_ticket->ticket->flags, pcmk__ticket_standby)) {
	constraints_for_ticket(rsc, new_rsc_ticket);
	}
	}

	// \return Standard Pacemaker return code
	static int
	unpack_rsc_ticket_set(xmlNode set, pcmk__ticket_t ticket,
	const char loss_policy, pcmk_scheduler_t scheduler)
	{
	const char *set_id = NULL;
	const char *role = NULL;

	CRM_CHECK(set != NULL, return EINVAL);
	CRM_CHECK(ticket != NULL, return EINVAL);

	set_id = pcmk__xe_id(set);
	if (set_id == NULL) {
	pcmk__config_err("Ignoring <" PCMK_XE_RESOURCE_SET "> without "
	PCMK_XA_ID);
	return pcmk_rc_unpack_error;
	}

	role = crm_element_value(set, PCMK_XA_ROLE);

	for (xmlNode *xml_rsc = pcmk__xe_first_child(set, PCMK_XE_RESOURCE_REF,
	NULL, NULL);
	xml_rsc != NULL; xml_rsc = pcmk__xe_next_same(xml_rsc)) {

	pcmk_resource_t *resource = NULL;

	resource = pcmk__find_constraint_resource(scheduler->resources,
	pcmk__xe_id(xml_rsc));
	if (resource == NULL) {
	pcmk__config_err("%s: No resource found for %s",
	set_id, pcmk__xe_id(xml_rsc));
	return pcmk_rc_unpack_error;
	}
	pcmk__rsc_trace(resource, "Resource '%s' depends on ticket '%s'",
	resource->id, ticket->id);
	rsc_ticket_new(set_id, resource, ticket, role, loss_policy);
	}

	return pcmk_rc_ok;
	}

	static void
	unpack_simple_rsc_ticket(xmlNode xml_obj, pcmk_scheduler_t scheduler)
	{
	const char *id = NULL;
	const char *ticket_str = crm_element_value(xml_obj, PCMK_XA_TICKET);
	const char *loss_policy = crm_element_value(xml_obj, PCMK_XA_LOSS_POLICY);

	pcmk__ticket_t *ticket = NULL;

	const char *rsc_id = crm_element_value(xml_obj, PCMK_XA_RSC);
	const char *state = crm_element_value(xml_obj, PCMK_XA_RSC_ROLE);

	// @COMPAT: Deprecated since 2.1.5
	const char *instance = crm_element_value(xml_obj, PCMK__XA_RSC_INSTANCE);

	pcmk_resource_t *rsc = NULL;

	if (instance != NULL) {
	pcmk__warn_once(pcmk__wo_coloc_inst,
	"Support for " PCMK__XA_RSC_INSTANCE " is deprecated "
	"and will be removed in a future release");
	}

	CRM_CHECK(xml_obj != NULL, return);

	id = pcmk__xe_id(xml_obj);
	if (id == NULL) {
	pcmk__config_err("Ignoring <%s> constraint without " PCMK_XA_ID,
	xml_obj->name);
	return;
	}

	if (ticket_str == NULL) {
	pcmk__config_err("Ignoring constraint '%s' without ticket specified",
	id);
	return;
	} else {
	ticket = g_hash_table_lookup(scheduler->tickets, ticket_str);
	}

	if (ticket == NULL) {
	pcmk__config_err("Ignoring constraint '%s' because ticket '%s' "
	"does not exist", id, ticket_str);
	return;
	}

	if (rsc_id == NULL) {
	pcmk__config_err("Ignoring constraint '%s' without resource", id);
	return;
	} else {
	rsc = pcmk__find_constraint_resource(scheduler->resources, rsc_id);
	}

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

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

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

	rsc_ticket_new(id, rsc, ticket, state, loss_policy);
	}

	// \return Standard Pacemaker return code
	static int
	unpack_rsc_ticket_tags(xmlNode xml_obj, xmlNode *expanded_xml,
	pcmk_scheduler_t *scheduler)
	{
	const char *id = NULL;
	const char *rsc_id = NULL;
	const char *state = NULL;

	pcmk_resource_t *rsc = NULL;
	pcmk__idref_t *tag = NULL;

	xmlNode *rsc_set = NULL;

	*expanded_xml = NULL;

	CRM_CHECK(xml_obj != NULL, return EINVAL);

	id = pcmk__xe_id(xml_obj);
	if (id == NULL) {
	pcmk__config_err("Ignoring <%s> constraint without " PCMK_XA_ID,
	xml_obj->name);
	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, scheduler);
	if (*expanded_xml != NULL) {
	crm_log_xml_trace(*expanded_xml, "Expanded rsc_ticket");
	return pcmk_rc_ok;
	}

	rsc_id = crm_element_value(xml_obj, PCMK_XA_RSC);
	if (rsc_id == NULL) {
	return pcmk_rc_ok;
	}

	if (!pcmk__valid_resource_or_tag(scheduler, rsc_id, &rsc, &tag)) {
	pcmk__config_err("Ignoring constraint '%s' because '%s' is not a "
	"valid resource or tag", id, rsc_id);
	return pcmk_rc_unpack_error;

	} else if (rsc != NULL) {
	// No template or tag is referenced
	return pcmk_rc_ok;
	}

	state = crm_element_value(xml_obj, PCMK_XA_RSC_ROLE);

	*expanded_xml = pcmk__xml_copy(NULL, xml_obj);

	/* Convert any template or tag reference in "rsc" into ticket
	* PCMK_XE_RESOURCE_SET
	*/
	if (!pcmk__tag_to_set(*expanded_xml, &rsc_set, PCMK_XA_RSC, false,
	scheduler)) {
	pcmk__xml_free(*expanded_xml);
	*expanded_xml = NULL;
	return pcmk_rc_unpack_error;
	}

	if (rsc_set != NULL) {
	if (state != NULL) {
	/* Move PCMK_XA_RSC_ROLE into converted PCMK_XE_RESOURCE_SET as a
	* PCMK_XA_ROLE attribute
	*/
	crm_xml_add(rsc_set, PCMK_XA_ROLE, state);
	pcmk__xe_remove_attr(*expanded_xml, PCMK_XA_RSC_ROLE);
	}

	} else {
	pcmk__xml_free(*expanded_xml);
	*expanded_xml = NULL;
	}

	return pcmk_rc_ok;
	}

	void
	pcmk__unpack_rsc_ticket(xmlNode xml_obj, pcmk_scheduler_t scheduler)
	{
	xmlNode *set = NULL;
	bool any_sets = false;

	const char *id = NULL;
	const char *ticket_str = NULL;

	pcmk__ticket_t *ticket = NULL;

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

	CRM_CHECK(xml_obj != NULL, return);

	id = pcmk__xe_id(xml_obj);
	if (id == NULL) {
	pcmk__config_err("Ignoring <%s> constraint without " PCMK_XA_ID,
	xml_obj->name);
	return;
	}

	if (scheduler->tickets == NULL) {
	scheduler->tickets = pcmk__strkey_table(free, destroy_ticket);
	}

	ticket_str = crm_element_value(xml_obj, PCMK_XA_TICKET);
	if (ticket_str == NULL) {
	pcmk__config_err("Ignoring constraint '%s' without ticket", id);
	return;
	} else {
	ticket = g_hash_table_lookup(scheduler->tickets, ticket_str);
	}

	if (ticket == NULL) {
	ticket = ticket_new(ticket_str, scheduler);
	if (ticket == NULL) {
	return;
	}
	}

	if (unpack_rsc_ticket_tags(xml_obj, &expanded_xml,
	scheduler) != pcmk_rc_ok) {
	return;
	}
	if (expanded_xml != NULL) {
	orig_xml = xml_obj;
	xml_obj = expanded_xml;
	}

	for (set = pcmk__xe_first_child(xml_obj, PCMK_XE_RESOURCE_SET, NULL, NULL);
	set != NULL; set = pcmk__xe_next_same(set)) {

	const char *loss_policy = NULL;

	any_sets = true;
	set = pcmk__xe_resolve_idref(set, scheduler->input);
	loss_policy = crm_element_value(xml_obj, PCMK_XA_LOSS_POLICY);

	if ((set == NULL) // Configuration error, message already logged
	\|\| (unpack_rsc_ticket_set(set, ticket, loss_policy,
	scheduler) != pcmk_rc_ok)) {
	if (expanded_xml != NULL) {
	pcmk__xml_free(expanded_xml);
	}
	return;
	}
	}

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

	if (!any_sets) {
	unpack_simple_rsc_ticket(xml_obj, scheduler);
	}
	}

	/*!
	* \internal
	* \brief Ban resource from a node if it doesn't have a promotion ticket
	*
	* If a resource has tickets for the promoted role, and the ticket is either not
	* granted or set to standby, then ban the resource from all nodes.
	*
	* \param[in,out] rsc Resource to check
	*/
	void
	pcmk__require_promotion_tickets(pcmk_resource_t *rsc)
	{
	for (GList *item = rsc->private->ticket_constraints;
	item != NULL; item = item->next) {

	rsc_ticket_t rsc_ticket = (rsc_ticket_t ) item->data;

	if ((rsc_ticket->role == pcmk_role_promoted)
	- && (!rsc_ticket->ticket->granted \|\| rsc_ticket->ticket->standby)) {
	+ && (!pcmk_is_set(rsc_ticket->ticket->flags, pcmk__ticket_granted)
	+ \|\| pcmk_is_set(rsc_ticket->ticket->flags,
	+ pcmk__ticket_standby))) {
	resource_location(rsc, NULL, -PCMK_SCORE_INFINITY,
	"__stateful_without_ticket__",
	rsc->private->scheduler);
	}
	}
	}
	diff --git a/lib/pacemaker/pcmk_ticket.c b/lib/pacemaker/pcmk_ticket.c
	index e9a04d265c..91f4d21815 100644
	--- a/lib/pacemaker/pcmk_ticket.c
	+++ b/lib/pacemaker/pcmk_ticket.c
	@@ -1,553 +1,554 @@
	/*
	* Copyright 2024 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/cib/internal.h>
	#include <crm/pengine/internal.h>

	#include <pacemaker.h>
	#include <pacemaker-internal.h>

	#include "libpacemaker_private.h"

	static int
	build_ticket_modify_xml(cib_t cib, const char ticket_id, xmlNode **ticket_state_xml,
	xmlNode **xml_top)
	{
	int rc = pcmk__get_ticket_state(cib, ticket_id, ticket_state_xml);

	if (rc == pcmk_rc_ok \|\| rc == pcmk_rc_duplicate_id) {
	/* Ticket(s) found - return their state */
	xml_top = ticket_state_xml;

	} else if (rc == ENXIO) {
	/* No ticket found - build the XML needed to create it */
	xmlNode *xml_obj = NULL;

	*xml_top = pcmk__xe_create(NULL, PCMK_XE_STATUS);
	xml_obj = pcmk__xe_create(*xml_top, PCMK_XE_TICKETS);
	*ticket_state_xml = pcmk__xe_create(xml_obj, PCMK__XE_TICKET_STATE);
	crm_xml_add(*ticket_state_xml, PCMK_XA_ID, ticket_id);

	rc = pcmk_rc_ok;

	} else {
	/* Some other error occurred - clean up and return */
	pcmk__xml_free(*ticket_state_xml);
	}

	return rc;
	}

	static void
	add_attribute_xml(pcmk_scheduler_t scheduler, const char ticket_id,
	GHashTable attr_set, xmlNode *ticket_state_xml)
	{
	GHashTableIter hash_iter;
	char *key = NULL;
	char *value = NULL;

	pcmk__ticket_t *ticket = g_hash_table_lookup(scheduler->tickets, ticket_id);

	g_hash_table_iter_init(&hash_iter, attr_set);
	while (g_hash_table_iter_next(&hash_iter, (gpointer ) & key, (gpointer ) & value)) {
	crm_xml_add(*ticket_state_xml, key, value);

	if (pcmk__str_eq(key, PCMK__XA_GRANTED, pcmk__str_none)
	- && (ticket == NULL \|\| ticket->granted == FALSE)
	+ && ((ticket == NULL)
	+ \|\| !pcmk_is_set(ticket->flags, pcmk__ticket_granted))
	&& crm_is_true(value)) {

	char *now = pcmk__ttoa(time(NULL));

	crm_xml_add(*ticket_state_xml, PCMK_XA_LAST_GRANTED, now);
	free(now);
	}
	}
	}

	int
	pcmk__get_ticket_state(cib_t cib, const char ticket_id, xmlNode **state)
	{
	int rc = pcmk_rc_ok;
	xmlNode *xml_search = NULL;
	char *xpath = NULL;

	CRM_ASSERT(cib!= NULL && state != NULL);
	*state = NULL;

	if (ticket_id != NULL) {
	xpath = crm_strdup_printf("/" PCMK_XE_CIB "/" PCMK_XE_STATUS "/" PCMK_XE_TICKETS
	"/" PCMK__XE_TICKET_STATE "[@" PCMK_XA_ID "=\"%s\"]",
	ticket_id);
	} else {
	xpath = crm_strdup_printf("/" PCMK_XE_CIB "/" PCMK_XE_STATUS "/" PCMK_XE_TICKETS);
	}

	rc = cib->cmds->query(cib, xpath, &xml_search, cib_sync_call\|cib_xpath);
	rc = pcmk_legacy2rc(rc);

	if (rc == pcmk_rc_ok) {
	crm_log_xml_debug(xml_search, "Match");

	if (xml_search->children != NULL && ticket_id != NULL) {
	rc = pcmk_rc_duplicate_id;
	}
	}

	free(xpath);

	*state = xml_search;
	return rc;
	}

	int
	pcmk__ticket_constraints(pcmk__output_t out, cib_t cib, const char *ticket_id)
	{
	int rc = pcmk_rc_ok;
	xmlNode *result = NULL;
	const char *xpath_base = NULL;
	char *xpath = NULL;

	CRM_ASSERT(out != NULL && cib != NULL);

	xpath_base = pcmk_cib_xpath_for(PCMK_XE_CONSTRAINTS);
	CRM_ASSERT(xpath_base != NULL);

	if (ticket_id != NULL) {
	xpath = crm_strdup_printf("%s/" PCMK_XE_RSC_TICKET "[@" PCMK_XA_TICKET "=\"%s\"]",
	xpath_base, ticket_id);
	} else {
	xpath = crm_strdup_printf("%s/" PCMK_XE_RSC_TICKET, xpath_base);
	}

	rc = cib->cmds->query(cib, xpath, &result, cib_sync_call\|cib_xpath);
	rc = pcmk_legacy2rc(rc);

	if (result != NULL) {
	out->message(out, "ticket-constraints", result);
	pcmk__xml_free(result);
	}

	free(xpath);
	return rc;
	}

	int
	pcmk_ticket_constraints(xmlNodePtr xml, const char ticket_id)
	{
	pcmk__output_t *out = NULL;
	int rc = pcmk_rc_ok;
	cib_t *cib = NULL;

	rc = pcmk__setup_output_cib_sched(&out, &cib, NULL, xml);
	if (rc != pcmk_rc_ok) {
	goto done;
	}

	rc = pcmk__ticket_constraints(out, cib, ticket_id);

	done:
	if (cib != NULL) {
	cib__clean_up_connection(&cib);
	}

	pcmk__xml_output_finish(out, pcmk_rc2exitc(rc), xml);
	return rc;
	}

	static int
	delete_single_ticket(xmlNode child, void userdata)
	{
	int rc = pcmk_rc_ok;
	cib_t cib = (cib_t ) userdata;

	rc = cib->cmds->remove(cib, PCMK_XE_STATUS, child, cib_sync_call);
	rc = pcmk_legacy2rc(rc);

	return rc;
	}

	int
	pcmk__ticket_delete(pcmk__output_t out, cib_t cib, pcmk_scheduler_t *scheduler,
	const char *ticket_id, bool force)
	{
	int rc = pcmk_rc_ok;
	xmlNode *state = NULL;

	CRM_ASSERT(cib != NULL && scheduler != NULL);

	if (ticket_id == NULL) {
	return EINVAL;
	}

	if (!force) {
	pcmk__ticket_t *ticket = g_hash_table_lookup(scheduler->tickets,
	ticket_id);

	if (ticket == NULL) {
	return ENXIO;
	}

	- if (ticket->granted) {
	+ if (pcmk_is_set(ticket->flags, pcmk__ticket_granted)) {
	return EACCES;
	}
	}

	rc = pcmk__get_ticket_state(cib, ticket_id, &state);

	if (rc == pcmk_rc_duplicate_id) {
	out->info(out, "Multiple " PCMK__XE_TICKET_STATE "s match ticket=%s",
	ticket_id);

	} else if (rc == ENXIO) {
	return pcmk_rc_ok;

	} else if (rc != pcmk_rc_ok) {
	return rc;
	}

	crm_log_xml_debug(state, "Delete");

	if (rc == pcmk_rc_duplicate_id) {
	rc = pcmk__xe_foreach_child(state, NULL, delete_single_ticket, cib);
	} else {
	rc = delete_single_ticket(state, cib);
	}

	if (rc == pcmk_rc_ok) {
	out->info(out, "Cleaned up %s", ticket_id);
	}

	pcmk__xml_free(state);
	return rc;
	}

	int
	pcmk_ticket_delete(xmlNodePtr xml, const char ticket_id, bool force)
	{
	pcmk_scheduler_t *scheduler = NULL;
	pcmk__output_t *out = NULL;
	cib_t *cib = NULL;
	int rc = pcmk_rc_ok;

	rc = pcmk__setup_output_cib_sched(&out, &cib, &scheduler, xml);
	if (rc != pcmk_rc_ok) {
	goto done;
	}

	rc = pcmk__ticket_delete(out, cib, scheduler, ticket_id, force);

	done:
	if (cib != NULL) {
	cib__clean_up_connection(&cib);
	}

	pcmk__xml_output_finish(out, pcmk_rc2exitc(rc), xml);
	pe_free_working_set(scheduler);
	return rc;
	}

	int
	pcmk__ticket_get_attr(pcmk__output_t out, pcmk_scheduler_t scheduler,
	const char ticket_id, const char attr_name,
	const char *attr_default)
	{
	int rc = pcmk_rc_ok;
	const char *attr_value = NULL;
	pcmk__ticket_t *ticket = NULL;

	CRM_ASSERT(out != NULL && scheduler != NULL);

	if (ticket_id == NULL \|\| attr_name == NULL) {
	return EINVAL;
	}

	ticket = g_hash_table_lookup(scheduler->tickets, ticket_id);

	if (ticket != NULL) {
	attr_value = g_hash_table_lookup(ticket->state, attr_name);
	}

	if (attr_value != NULL) {
	out->message(out, "ticket-attribute", ticket_id, attr_name, attr_value);
	} else if (attr_default != NULL) {
	out->message(out, "ticket-attribute", ticket_id, attr_name, attr_default);
	} else {
	rc = ENXIO;
	}

	return rc;
	}

	int
	pcmk_ticket_get_attr(xmlNodePtr xml, const char ticket_id,
	const char attr_name, const char attr_default)
	{
	pcmk_scheduler_t *scheduler = NULL;
	pcmk__output_t *out = NULL;
	int rc = pcmk_rc_ok;

	rc = pcmk__setup_output_cib_sched(&out, NULL, &scheduler, xml);
	if (rc != pcmk_rc_ok) {
	goto done;
	}

	rc = pcmk__ticket_get_attr(out, scheduler, ticket_id, attr_name, attr_default);

	done:
	pcmk__xml_output_finish(out, pcmk_rc2exitc(rc), xml);
	pe_free_working_set(scheduler);
	return rc;
	}

	int
	pcmk__ticket_info(pcmk__output_t out, pcmk_scheduler_t scheduler,
	const char *ticket_id, bool details, bool raw)
	{
	int rc = pcmk_rc_ok;

	CRM_ASSERT(out != NULL && scheduler != NULL);

	if (ticket_id != NULL) {
	GHashTable *tickets = NULL;
	pcmk__ticket_t *ticket = g_hash_table_lookup(scheduler->tickets,
	ticket_id);

	if (ticket == NULL) {
	return ENXIO;
	}

	/* The ticket-list message expects a GHashTable, so we'll construct
	* one with just this single item.
	*/
	tickets = pcmk__strkey_table(free, NULL);
	g_hash_table_insert(tickets, strdup(ticket->id), ticket);
	out->message(out, "ticket-list", tickets, false, raw, details);
	g_hash_table_destroy(tickets);

	} else {
	out->message(out, "ticket-list", scheduler->tickets, false, raw, details);
	}

	return rc;
	}

	int
	pcmk_ticket_info(xmlNodePtr xml, const char ticket_id)
	{
	pcmk_scheduler_t *scheduler = NULL;
	pcmk__output_t *out = NULL;
	int rc = pcmk_rc_ok;

	rc = pcmk__setup_output_cib_sched(&out, NULL, &scheduler, xml);
	if (rc != pcmk_rc_ok) {
	goto done;
	}

	pe__register_messages(out);

	/* XML output (which is the only format supported by public API functions
	* due to the use of pcmk__xml_output_new above) always prints all details,
	* so just pass false for the last two arguments.
	*/
	rc = pcmk__ticket_info(out, scheduler, ticket_id, false, false);

	done:
	pcmk__xml_output_finish(out, pcmk_rc2exitc(rc), xml);
	pe_free_working_set(scheduler);
	return rc;
	}

	int
	pcmk__ticket_remove_attr(pcmk__output_t out, cib_t cib, pcmk_scheduler_t *scheduler,
	const char ticket_id, GList attr_delete, bool force)
	{
	xmlNode *ticket_state_xml = NULL;
	xmlNode *xml_top = NULL;
	int rc = pcmk_rc_ok;

	CRM_ASSERT(out != NULL && cib != NULL && scheduler != NULL);

	if (ticket_id == NULL) {
	return EINVAL;
	}

	/* Nothing to do */
	if (attr_delete == NULL) {
	return pcmk_rc_ok;
	}

	rc = build_ticket_modify_xml(cib, ticket_id, &ticket_state_xml, &xml_top);

	if (rc == pcmk_rc_duplicate_id) {
	out->info(out, "Multiple " PCMK__XE_TICKET_STATE "s match ticket=%s", ticket_id);
	} else if (rc != pcmk_rc_ok) {
	pcmk__xml_free(ticket_state_xml);
	return rc;
	}

	for (GList *list_iter = attr_delete; list_iter != NULL; list_iter = list_iter->next) {
	const char *key = list_iter->data;

	if (!force && pcmk__str_eq(key, PCMK__XA_GRANTED, pcmk__str_none)) {
	pcmk__xml_free(ticket_state_xml);
	return EACCES;
	}

	pcmk__xe_remove_attr(ticket_state_xml, key);
	}

	crm_log_xml_debug(xml_top, "Replace");
	rc = cib->cmds->replace(cib, PCMK_XE_STATUS, ticket_state_xml, cib_sync_call);
	rc = pcmk_legacy2rc(rc);

	pcmk__xml_free(xml_top);
	return rc;
	}

	int
	pcmk_ticket_remove_attr(xmlNodePtr xml, const char ticket_id, GList *attr_delete, bool force)
	{
	pcmk_scheduler_t *scheduler = NULL;
	pcmk__output_t *out = NULL;
	int rc = pcmk_rc_ok;
	cib_t *cib = NULL;

	rc = pcmk__setup_output_cib_sched(&out, &cib, &scheduler, xml);
	if (rc != pcmk_rc_ok) {
	goto done;
	}

	rc = pcmk__ticket_remove_attr(out, cib, scheduler, ticket_id, attr_delete, force);

	done:
	if (cib != NULL) {
	cib__clean_up_connection(&cib);
	}

	pcmk__xml_output_finish(out, pcmk_rc2exitc(rc), xml);
	pe_free_working_set(scheduler);
	return rc;
	}

	int
	pcmk__ticket_set_attr(pcmk__output_t out, cib_t cib, pcmk_scheduler_t *scheduler,
	const char ticket_id, GHashTable attr_set, bool force)
	{
	xmlNode *ticket_state_xml = NULL;
	xmlNode *xml_top = NULL;
	int rc = pcmk_rc_ok;

	CRM_ASSERT(out != NULL && cib != NULL && scheduler != NULL);

	if (ticket_id == NULL) {
	return EINVAL;
	}

	/* Nothing to do */
	if (attr_set == NULL \|\| g_hash_table_size(attr_set) == 0) {
	return pcmk_rc_ok;
	}

	rc = build_ticket_modify_xml(cib, ticket_id, &ticket_state_xml, &xml_top);

	if (rc == pcmk_rc_duplicate_id) {
	out->info(out, "Multiple " PCMK__XE_TICKET_STATE "s match ticket=%s", ticket_id);
	} else if (rc != pcmk_rc_ok) {
	pcmk__xml_free(ticket_state_xml);
	return rc;
	}

	if (!force && g_hash_table_lookup(attr_set, PCMK__XA_GRANTED)) {
	pcmk__xml_free(ticket_state_xml);
	return EACCES;
	}

	add_attribute_xml(scheduler, ticket_id, attr_set, &ticket_state_xml);

	crm_log_xml_debug(xml_top, "Update");
	rc = cib->cmds->modify(cib, PCMK_XE_STATUS, xml_top, cib_sync_call);
	rc = pcmk_legacy2rc(rc);

	pcmk__xml_free(xml_top);
	return rc;
	}

	int
	pcmk_ticket_set_attr(xmlNodePtr xml, const char ticket_id, GHashTable *attr_set,
	bool force)
	{
	pcmk_scheduler_t *scheduler = NULL;
	pcmk__output_t *out = NULL;
	int rc = pcmk_rc_ok;
	cib_t *cib = NULL;

	rc = pcmk__setup_output_cib_sched(&out, &cib, &scheduler, xml);
	if (rc != pcmk_rc_ok) {
	goto done;
	}

	rc = pcmk__ticket_set_attr(out, cib, scheduler, ticket_id, attr_set, force);

	done:
	if (cib != NULL) {
	cib__clean_up_connection(&cib);
	}

	pcmk__xml_output_finish(out, pcmk_rc2exitc(rc), xml);
	pe_free_working_set(scheduler);
	return rc;
	}

	int
	pcmk__ticket_state(pcmk__output_t out, cib_t cib, const char *ticket_id)
	{
	xmlNode *state_xml = NULL;
	int rc = pcmk_rc_ok;

	CRM_ASSERT(out != NULL && cib != NULL);

	rc = pcmk__get_ticket_state(cib, ticket_id, &state_xml);

	if (rc == pcmk_rc_duplicate_id) {
	out->info(out, "Multiple " PCMK__XE_TICKET_STATE "s match ticket=%s",
	ticket_id);
	}

	if (state_xml != NULL) {
	out->message(out, "ticket-state", state_xml);
	pcmk__xml_free(state_xml);
	}

	return rc;
	}

	int
	pcmk_ticket_state(xmlNodePtr xml, const char ticket_id)
	{
	pcmk__output_t *out = NULL;
	int rc = pcmk_rc_ok;
	cib_t *cib = NULL;

	rc = pcmk__setup_output_cib_sched(&out, &cib, NULL, xml);
	if (rc != pcmk_rc_ok) {
	goto done;
	}

	rc = pcmk__ticket_state(out, cib, ticket_id);

	done:
	if (cib != NULL) {
	cib__clean_up_connection(&cib);
	}

	pcmk__xml_output_finish(out, pcmk_rc2exitc(rc), xml);
	return rc;
	}
	diff --git a/lib/pengine/pe_output.c b/lib/pengine/pe_output.c
	index 2ada2fc28d..2389c396fb 100644
	--- a/lib/pengine/pe_output.c
	+++ b/lib/pengine/pe_output.c
	@@ -1,3452 +1,3460 @@
	/*
	* Copyright 2019-2024 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.
	*/

	#include <crm_internal.h>

	#include <stdint.h>

	#include <crm/common/xml_internal.h>
	#include <crm/common/output.h>
	#include <crm/common/scheduler_internal.h>
	#include <crm/cib/util.h>
	#include <crm/common/xml.h>
	#include <crm/pengine/internal.h>

	const char *
	pe__resource_description(const pcmk_resource_t *rsc, uint32_t show_opts)
	{
	const char * desc = NULL;

	// User-supplied description
	if (pcmk_any_flags_set(show_opts, pcmk_show_rsc_only\|pcmk_show_description)) {
	desc = crm_element_value(rsc->private->xml, PCMK_XA_DESCRIPTION);
	}
	return desc;
	}

	/* Never display node attributes whose name starts with one of these prefixes */
	#define FILTER_STR { PCMK__FAIL_COUNT_PREFIX, PCMK__LAST_FAILURE_PREFIX, \
	PCMK__NODE_ATTR_SHUTDOWN, PCMK_NODE_ATTR_TERMINATE, \
	PCMK_NODE_ATTR_STANDBY, "#", NULL }

	static int
	compare_attribute(gconstpointer a, gconstpointer b)
	{
	int rc;

	rc = strcmp((const char )a, (const char )b);

	return rc;
	}

	/*!
	* \internal
	* \brief Determine whether extended information about an attribute should be added.
	*
	* \param[in] node Node that ran this resource
	* \param[in,out] rsc_list List of resources for this node
	* \param[in,out] scheduler Scheduler data
	* \param[in] attrname Attribute to find
	* \param[out] expected_score Expected value for this attribute
	*
	* \return true if extended information should be printed, false otherwise
	* \note Currently, extended information is only supported for ping/pingd
	* resources, for which a message will be printed if connectivity is lost
	* or degraded.
	*/
	static bool
	add_extra_info(const pcmk_node_t node, GList rsc_list,
	pcmk_scheduler_t scheduler, const char attrname,
	int *expected_score)
	{
	GList *gIter = NULL;

	for (gIter = rsc_list; gIter != NULL; gIter = gIter->next) {
	pcmk_resource_t rsc = (pcmk_resource_t ) gIter->data;
	const char *type = g_hash_table_lookup(rsc->private->meta,
	PCMK_XA_TYPE);
	const char *name = NULL;
	GHashTable *params = NULL;

	if (rsc->private->children != NULL) {
	if (add_extra_info(node, rsc->private->children, scheduler,
	attrname, expected_score)) {
	return true;
	}
	}

	if (!pcmk__strcase_any_of(type, "ping", "pingd", NULL)) {
	continue;
	}

	params = pe_rsc_params(rsc, node, scheduler);
	name = g_hash_table_lookup(params, PCMK_XA_NAME);

	if (name == NULL) {
	name = "pingd";
	}

	/* To identify the resource with the attribute name. */
	if (pcmk__str_eq(name, attrname, pcmk__str_casei)) {
	int host_list_num = 0;
	const char *hosts = g_hash_table_lookup(params, "host_list");
	const char *multiplier = g_hash_table_lookup(params, "multiplier");
	int multiplier_i;

	if (hosts) {
	char **host_list = g_strsplit(hosts, " ", 0);
	host_list_num = g_strv_length(host_list);
	g_strfreev(host_list);
	}

	if ((multiplier == NULL)
	\|\| (pcmk__scan_min_int(multiplier, &multiplier_i,
	INT_MIN) != pcmk_rc_ok)) {
	/* The ocf:pacemaker:ping resource agent defaults multiplier to
	* 1. The agent currently does not handle invalid text, but it
	* should, and this would be a reasonable choice ...
	*/
	multiplier_i = 1;
	}
	expected_score = host_list_num multiplier_i;

	return true;
	}
	}
	return false;
	}

	static GList *
	filter_attr_list(GList attr_list, char name)
	{
	int i;
	const char *filt_str[] = FILTER_STR;

	CRM_CHECK(name != NULL, return attr_list);

	/* filtering automatic attributes */
	for (i = 0; filt_str[i] != NULL; i++) {
	if (g_str_has_prefix(name, filt_str[i])) {
	return attr_list;
	}
	}

	return g_list_insert_sorted(attr_list, name, compare_attribute);
	}

	static GList *
	get_operation_list(xmlNode *rsc_entry) {
	GList *op_list = NULL;
	xmlNode *rsc_op = NULL;

	for (rsc_op = pcmk__xe_first_child(rsc_entry, NULL, NULL, NULL);
	rsc_op != NULL; rsc_op = pcmk__xe_next(rsc_op)) {

	const char *task = crm_element_value(rsc_op, PCMK_XA_OPERATION);
	const char *interval_ms_s = crm_element_value(rsc_op,
	PCMK_META_INTERVAL);
	const char *op_rc = crm_element_value(rsc_op, PCMK__XA_RC_CODE);
	int op_rc_i;

	pcmk__scan_min_int(op_rc, &op_rc_i, 0);

	/* Display 0-interval monitors as "probe" */
	if (pcmk__str_eq(task, PCMK_ACTION_MONITOR, pcmk__str_casei)
	&& pcmk__str_eq(interval_ms_s, "0", pcmk__str_null_matches \| pcmk__str_casei)) {
	task = "probe";
	}

	/* Ignore notifies and some probes */
	if (pcmk__str_eq(task, PCMK_ACTION_NOTIFY, pcmk__str_none)
	\|\| (pcmk__str_eq(task, "probe", pcmk__str_none)
	&& (op_rc_i == CRM_EX_NOT_RUNNING))) {
	continue;
	}

	if (pcmk__xe_is(rsc_op, PCMK__XE_LRM_RSC_OP)) {
	op_list = g_list_append(op_list, rsc_op);
	}
	}

	op_list = g_list_sort(op_list, sort_op_by_callid);
	return op_list;
	}

	static void
	add_dump_node(gpointer key, gpointer value, gpointer user_data)
	{
	xmlNodePtr node = user_data;

	node = pcmk__xe_create(node, (const char *) key);
	pcmk__xe_set_content(node, "%s", (const char *) value);
	}

	static void
	append_dump_text(gpointer key, gpointer value, gpointer user_data)
	{
	char **dump_text = user_data;
	char *new_text = crm_strdup_printf("%s %s=%s",
	dump_text, (char )key, (char *)value);

	free(*dump_text);
	*dump_text = new_text;
	}

	#define XPATH_STACK "//" PCMK_XE_NVPAIR \
	"[@" PCMK_XA_NAME "='" \
	PCMK_OPT_CLUSTER_INFRASTRUCTURE "']"

	static const char *
	get_cluster_stack(pcmk_scheduler_t *scheduler)
	{
	xmlNode *stack = get_xpath_object(XPATH_STACK, scheduler->input, LOG_DEBUG);

	if (stack != NULL) {
	return crm_element_value(stack, PCMK_XA_VALUE);
	}
	return PCMK_VALUE_UNKNOWN;
	}

	static char *
	last_changed_string(const char last_written, const char user,
	const char client, const char origin) {
	if (last_written != NULL \|\| user != NULL \|\| client != NULL \|\| origin != NULL) {
	return crm_strdup_printf("%s%s%s%s%s%s%s",
	last_written ? last_written : "",
	user ? " by " : "",
	user ? user : "",
	client ? " via " : "",
	client ? client : "",
	origin ? " on " : "",
	origin ? origin : "");
	} else {
	return strdup("");
	}
	}

	static char *
	op_history_string(xmlNode xml_op, const char task, const char *interval_ms_s,
	int rc, bool print_timing) {
	const char *call = crm_element_value(xml_op, PCMK__XA_CALL_ID);
	char *interval_str = NULL;
	char *buf = NULL;

	if (interval_ms_s && !pcmk__str_eq(interval_ms_s, "0", pcmk__str_casei)) {
	char *pair = pcmk__format_nvpair(PCMK_XA_INTERVAL, interval_ms_s, "ms");
	interval_str = crm_strdup_printf(" %s", pair);
	free(pair);
	}

	if (print_timing) {
	char *last_change_str = NULL;
	char *exec_str = NULL;
	char *queue_str = NULL;

	const char *value = NULL;

	time_t epoch = 0;

	if ((crm_element_value_epoch(xml_op, PCMK_XA_LAST_RC_CHANGE,
	&epoch) == pcmk_ok)
	&& (epoch > 0)) {
	char *epoch_str = pcmk__epoch2str(&epoch, 0);

	last_change_str = crm_strdup_printf(" %s=\"%s\"",
	PCMK_XA_LAST_RC_CHANGE,
	pcmk__s(epoch_str, ""));
	free(epoch_str);
	}

	value = crm_element_value(xml_op, PCMK_XA_EXEC_TIME);
	if (value) {
	char *pair = pcmk__format_nvpair(PCMK_XA_EXEC_TIME, value, "ms");
	exec_str = crm_strdup_printf(" %s", pair);
	free(pair);
	}

	value = crm_element_value(xml_op, PCMK_XA_QUEUE_TIME);
	if (value) {
	char *pair = pcmk__format_nvpair(PCMK_XA_QUEUE_TIME, value, "ms");
	queue_str = crm_strdup_printf(" %s", pair);
	free(pair);
	}

	buf = crm_strdup_printf("(%s) %s:%s%s%s%s rc=%d (%s)", call, task,
	interval_str ? interval_str : "",
	last_change_str ? last_change_str : "",
	exec_str ? exec_str : "",
	queue_str ? queue_str : "",
	rc, services_ocf_exitcode_str(rc));

	if (last_change_str) {
	free(last_change_str);
	}

	if (exec_str) {
	free(exec_str);
	}

	if (queue_str) {
	free(queue_str);
	}
	} else {
	buf = crm_strdup_printf("(%s) %s%s%s", call, task,
	interval_str ? ":" : "",
	interval_str ? interval_str : "");
	}

	if (interval_str) {
	free(interval_str);
	}

	return buf;
	}

	static char *
	resource_history_string(pcmk_resource_t rsc, const char rsc_id, bool all,
	int failcount, time_t last_failure) {
	char *buf = NULL;

	if (rsc == NULL) {
	buf = crm_strdup_printf("%s: orphan", rsc_id);
	} else if (all \|\| failcount \|\| last_failure > 0) {
	char *failcount_s = NULL;
	char *lastfail_s = NULL;

	if (failcount > 0) {
	failcount_s = crm_strdup_printf(" %s=%d",
	PCMK_XA_FAIL_COUNT, failcount);
	} else {
	failcount_s = strdup("");
	}
	if (last_failure > 0) {
	buf = pcmk__epoch2str(&last_failure, 0);
	lastfail_s = crm_strdup_printf(" %s='%s'",
	PCMK_XA_LAST_FAILURE, buf);
	free(buf);
	}

	buf = crm_strdup_printf("%s: " PCMK_META_MIGRATION_THRESHOLD "=%d%s%s",
	rsc_id, rsc->private->ban_after_failures,
	failcount_s, pcmk__s(lastfail_s, ""));
	free(failcount_s);
	free(lastfail_s);
	} else {
	buf = crm_strdup_printf("%s:", rsc_id);
	}

	return buf;
	}

	/*!
	* \internal
	* \brief Get a node's feature set for status display purposes
	*
	* \param[in] node Node to check
	*
	* \return String representation of feature set if the node is fully up (using
	* "<3.15.1" for older nodes that don't set the #feature-set attribute),
	* otherwise NULL
	*/
	static const char *
	get_node_feature_set(const pcmk_node_t *node)
	{
	if (node->details->online
	&& pcmk_is_set(node->private->flags, pcmk__node_expected_up)
	&& !pcmk__is_pacemaker_remote_node(node)) {

	const char *feature_set = g_hash_table_lookup(node->private->attrs,
	CRM_ATTR_FEATURE_SET);

	/* The feature set attribute is present since 3.15.1. If it is missing,
	* then the node must be running an earlier version.
	*/
	return pcmk__s(feature_set, "<3.15.1");
	}
	return NULL;
	}

	static bool
	is_mixed_version(pcmk_scheduler_t *scheduler)
	{
	const char *feature_set = NULL;
	for (GList *gIter = scheduler->nodes; gIter != NULL; gIter = gIter->next) {
	pcmk_node_t *node = gIter->data;
	const char *node_feature_set = get_node_feature_set(node);
	if (node_feature_set != NULL) {
	if (feature_set == NULL) {
	feature_set = node_feature_set;
	} else if (strcmp(feature_set, node_feature_set) != 0) {
	return true;
	}
	}
	}
	return false;
	}

	static void
	formatted_xml_buf(const pcmk_resource_t rsc, GString xml_buf, bool raw)
	{
	if (raw && (rsc->private->orig_xml != NULL)) {
	pcmk__xml_string(rsc->private->orig_xml, pcmk__xml_fmt_pretty, xml_buf,
	0);
	} else {
	pcmk__xml_string(rsc->private->xml, pcmk__xml_fmt_pretty, xml_buf, 0);
	}
	}

	#define XPATH_DC_VERSION "//" PCMK_XE_NVPAIR \
	"[@" PCMK_XA_NAME "='" PCMK_OPT_DC_VERSION "']"

	PCMK__OUTPUT_ARGS("cluster-summary", "pcmk_scheduler_t *",
	"enum pcmk_pacemakerd_state", "uint32_t", "uint32_t")
	static int
	cluster_summary(pcmk__output_t *out, va_list args) {
	pcmk_scheduler_t scheduler = va_arg(args, pcmk_scheduler_t );
	enum pcmk_pacemakerd_state pcmkd_state =
	(enum pcmk_pacemakerd_state) va_arg(args, int);
	uint32_t section_opts = va_arg(args, uint32_t);
	uint32_t show_opts = va_arg(args, uint32_t);

	int rc = pcmk_rc_no_output;
	const char *stack_s = get_cluster_stack(scheduler);

	if (pcmk_is_set(section_opts, pcmk_section_stack)) {
	PCMK__OUTPUT_LIST_HEADER(out, false, rc, "Cluster Summary");
	out->message(out, "cluster-stack", stack_s, pcmkd_state);
	}

	if (pcmk_is_set(section_opts, pcmk_section_dc)) {
	xmlNode *dc_version = get_xpath_object(XPATH_DC_VERSION,
	scheduler->input, LOG_DEBUG);
	const char *dc_version_s = dc_version?
	crm_element_value(dc_version, PCMK_XA_VALUE)
	: NULL;
	const char *quorum = crm_element_value(scheduler->input,
	PCMK_XA_HAVE_QUORUM);
	char *dc_name = scheduler->dc_node? pe__node_display_name(scheduler->dc_node, pcmk_is_set(show_opts, pcmk_show_node_id)) : NULL;
	bool mixed_version = is_mixed_version(scheduler);

	PCMK__OUTPUT_LIST_HEADER(out, false, rc, "Cluster Summary");
	out->message(out, "cluster-dc", scheduler->dc_node, quorum,
	dc_version_s, dc_name, mixed_version);
	free(dc_name);
	}

	if (pcmk_is_set(section_opts, pcmk_section_times)) {
	const char *last_written = crm_element_value(scheduler->input,
	PCMK_XA_CIB_LAST_WRITTEN);
	const char *user = crm_element_value(scheduler->input,
	PCMK_XA_UPDATE_USER);
	const char *client = crm_element_value(scheduler->input,
	PCMK_XA_UPDATE_CLIENT);
	const char *origin = crm_element_value(scheduler->input,
	PCMK_XA_UPDATE_ORIGIN);

	PCMK__OUTPUT_LIST_HEADER(out, false, rc, "Cluster Summary");
	out->message(out, "cluster-times",
	scheduler->localhost, last_written, user, client, origin);
	}

	if (pcmk_is_set(section_opts, pcmk_section_counts)) {
	PCMK__OUTPUT_LIST_HEADER(out, false, rc, "Cluster Summary");
	out->message(out, "cluster-counts", g_list_length(scheduler->nodes),
	scheduler->ninstances, scheduler->disabled_resources,
	scheduler->blocked_resources);
	}

	if (pcmk_is_set(section_opts, pcmk_section_options)) {
	PCMK__OUTPUT_LIST_HEADER(out, false, rc, "Cluster Summary");
	out->message(out, "cluster-options", scheduler);
	}

	PCMK__OUTPUT_LIST_FOOTER(out, rc);

	if (pcmk_is_set(section_opts, pcmk_section_maint_mode)) {
	if (out->message(out, "maint-mode", scheduler->flags) == pcmk_rc_ok) {
	rc = pcmk_rc_ok;
	}
	}

	return rc;
	}

	PCMK__OUTPUT_ARGS("cluster-summary", "pcmk_scheduler_t *",
	"enum pcmk_pacemakerd_state", "uint32_t", "uint32_t")
	static int
	cluster_summary_html(pcmk__output_t *out, va_list args) {
	pcmk_scheduler_t scheduler = va_arg(args, pcmk_scheduler_t );
	enum pcmk_pacemakerd_state pcmkd_state =
	(enum pcmk_pacemakerd_state) va_arg(args, int);
	uint32_t section_opts = va_arg(args, uint32_t);
	uint32_t show_opts = va_arg(args, uint32_t);

	int rc = pcmk_rc_no_output;
	const char *stack_s = get_cluster_stack(scheduler);

	if (pcmk_is_set(section_opts, pcmk_section_stack)) {
	PCMK__OUTPUT_LIST_HEADER(out, false, rc, "Cluster Summary");
	out->message(out, "cluster-stack", stack_s, pcmkd_state);
	}

	/* Always print DC if none, even if not requested */
	if ((scheduler->dc_node == NULL)
	\|\| pcmk_is_set(section_opts, pcmk_section_dc)) {
	xmlNode *dc_version = get_xpath_object(XPATH_DC_VERSION,
	scheduler->input, LOG_DEBUG);
	const char *dc_version_s = dc_version?
	crm_element_value(dc_version, PCMK_XA_VALUE)
	: NULL;
	const char *quorum = crm_element_value(scheduler->input,
	PCMK_XA_HAVE_QUORUM);
	char *dc_name = scheduler->dc_node? pe__node_display_name(scheduler->dc_node, pcmk_is_set(show_opts, pcmk_show_node_id)) : NULL;
	bool mixed_version = is_mixed_version(scheduler);

	PCMK__OUTPUT_LIST_HEADER(out, false, rc, "Cluster Summary");
	out->message(out, "cluster-dc", scheduler->dc_node, quorum,
	dc_version_s, dc_name, mixed_version);
	free(dc_name);
	}

	if (pcmk_is_set(section_opts, pcmk_section_times)) {
	const char *last_written = crm_element_value(scheduler->input,
	PCMK_XA_CIB_LAST_WRITTEN);
	const char *user = crm_element_value(scheduler->input,
	PCMK_XA_UPDATE_USER);
	const char *client = crm_element_value(scheduler->input,
	PCMK_XA_UPDATE_CLIENT);
	const char *origin = crm_element_value(scheduler->input,
	PCMK_XA_UPDATE_ORIGIN);

	PCMK__OUTPUT_LIST_HEADER(out, false, rc, "Cluster Summary");
	out->message(out, "cluster-times",
	scheduler->localhost, last_written, user, client, origin);
	}

	if (pcmk_is_set(section_opts, pcmk_section_counts)) {
	PCMK__OUTPUT_LIST_HEADER(out, false, rc, "Cluster Summary");
	out->message(out, "cluster-counts", g_list_length(scheduler->nodes),
	scheduler->ninstances, scheduler->disabled_resources,
	scheduler->blocked_resources);
	}

	if (pcmk_is_set(section_opts, pcmk_section_options)) {
	/* Kind of a hack - close the list we may have opened earlier in this
	* function so we can put all the options into their own list. We
	* only want to do this on HTML output, though.
	*/
	PCMK__OUTPUT_LIST_FOOTER(out, rc);

	out->begin_list(out, NULL, NULL, "Config Options");
	out->message(out, "cluster-options", scheduler);
	}

	PCMK__OUTPUT_LIST_FOOTER(out, rc);

	if (pcmk_is_set(section_opts, pcmk_section_maint_mode)) {
	if (out->message(out, "maint-mode", scheduler->flags) == pcmk_rc_ok) {
	rc = pcmk_rc_ok;
	}
	}

	return rc;
	}

	char *
	pe__node_display_name(pcmk_node_t *node, bool print_detail)
	{
	char *node_name;
	const char *node_host = NULL;
	const char *node_id = NULL;
	int name_len;

	CRM_ASSERT((node != NULL) && (node->private->name != NULL));

	/* Host is displayed only if this is a guest node and detail is requested */
	if (print_detail && pcmk__is_guest_or_bundle_node(node)) {
	const pcmk_resource_t *launcher = NULL;
	const pcmk_node_t *host_node = NULL;

	launcher = node->private->remote->private->launcher;
	host_node = pcmk__current_node(launcher);

	if (host_node && host_node->details) {
	node_host = host_node->private->name;
	}
	if (node_host == NULL) {
	node_host = ""; /* so we at least get "uname@" to indicate guest */
	}
	}

	/* Node ID is displayed if different from uname and detail is requested */
	if (print_detail
	&& !pcmk__str_eq(node->private->name, node->private->id,
	pcmk__str_casei)) {
	node_id = node->private->id;
	}

	/* Determine name length */
	name_len = strlen(node->private->name) + 1;
	if (node_host) {
	name_len += strlen(node_host) + 1; /* "@node_host" */
	}
	if (node_id) {
	name_len += strlen(node_id) + 3; /* + " (node_id)" */
	}

	/* Allocate and populate display name */
	node_name = pcmk__assert_alloc(name_len, sizeof(char));
	strcpy(node_name, node->private->name);
	if (node_host) {
	strcat(node_name, "@");
	strcat(node_name, node_host);
	}
	if (node_id) {
	strcat(node_name, " (");
	strcat(node_name, node_id);
	strcat(node_name, ")");
	}
	return node_name;
	}

	int
	pe__name_and_nvpairs_xml(pcmk__output_t out, bool is_list, const char tag_name,
	...)
	{
	xmlNodePtr xml_node = NULL;
	va_list pairs;

	CRM_ASSERT(tag_name != NULL);

	xml_node = pcmk__output_xml_peek_parent(out);
	CRM_ASSERT(xml_node != NULL);
	xml_node = pcmk__xe_create(xml_node, tag_name);

	va_start(pairs, tag_name);
	pcmk__xe_set_propv(xml_node, pairs);
	va_end(pairs);

	if (is_list) {
	pcmk__output_xml_push_parent(out, xml_node);
	}
	return pcmk_rc_ok;
	}

	static const char *
	role_desc(enum rsc_role_e role)
	{
	if (role == pcmk_role_promoted) {
	return "in " PCMK_ROLE_PROMOTED " role ";
	}
	return "";
	}

	PCMK__OUTPUT_ARGS("ban", "pcmk_node_t ", "pcmk__location_t ", "uint32_t")
	static int
	ban_html(pcmk__output_t *out, va_list args) {
	pcmk_node_t pe_node = va_arg(args, pcmk_node_t );
	pcmk__location_t location = va_arg(args, pcmk__location_t );
	uint32_t show_opts = va_arg(args, uint32_t);

	char *node_name = pe__node_display_name(pe_node,
	pcmk_is_set(show_opts, pcmk_show_node_id));
	char *buf = crm_strdup_printf("%s\tprevents %s from running %son %s",
	location->id, location->rsc->id,
	role_desc(location->role_filter), node_name);

	pcmk__output_create_html_node(out, "li", NULL, NULL, buf);

	free(node_name);
	free(buf);
	return pcmk_rc_ok;
	}

	PCMK__OUTPUT_ARGS("ban", "pcmk_node_t ", "pcmk__location_t ", "uint32_t")
	static int
	ban_text(pcmk__output_t *out, va_list args) {
	pcmk_node_t pe_node = va_arg(args, pcmk_node_t );
	pcmk__location_t location = va_arg(args, pcmk__location_t );
	uint32_t show_opts = va_arg(args, uint32_t);

	char *node_name = pe__node_display_name(pe_node,
	pcmk_is_set(show_opts, pcmk_show_node_id));
	out->list_item(out, NULL, "%s\tprevents %s from running %son %s",
	location->id, location->rsc->id,
	role_desc(location->role_filter), node_name);

	free(node_name);
	return pcmk_rc_ok;
	}

	PCMK__OUTPUT_ARGS("ban", "pcmk_node_t ", "pcmk__location_t ", "uint32_t")
	static int
	ban_xml(pcmk__output_t *out, va_list args) {
	pcmk_node_t pe_node = va_arg(args, pcmk_node_t );
	pcmk__location_t location = va_arg(args, pcmk__location_t );
	uint32_t show_opts G_GNUC_UNUSED = va_arg(args, uint32_t);

	const char *promoted_only = pcmk__btoa(location->role_filter == pcmk_role_promoted);
	char *weight_s = pcmk__itoa(pe_node->assign->score);

	pcmk__output_create_xml_node(out, PCMK_XE_BAN,
	PCMK_XA_ID, location->id,
	PCMK_XA_RESOURCE, location->rsc->id,
	PCMK_XA_NODE, pe_node->private->name,
	PCMK_XA_WEIGHT, weight_s,
	PCMK_XA_PROMOTED_ONLY, promoted_only,
	/* This is a deprecated alias for
	* promoted_only. Removing it will break
	* backward compatibility of the API schema,
	* which will require an API schema major
	* version bump.
	*/
	PCMK__XA_PROMOTED_ONLY_LEGACY, promoted_only,
	NULL);

	free(weight_s);
	return pcmk_rc_ok;
	}

	PCMK__OUTPUT_ARGS("ban-list", "pcmk_scheduler_t ", "const char ", "GList *",
	"uint32_t", "bool")
	static int
	ban_list(pcmk__output_t *out, va_list args) {
	pcmk_scheduler_t scheduler = va_arg(args, pcmk_scheduler_t );
	const char prefix = va_arg(args, const char );
	GList only_rsc = va_arg(args, GList );
	uint32_t show_opts = va_arg(args, uint32_t);
	bool print_spacer = va_arg(args, int);

	GList gIter, gIter2;
	int rc = pcmk_rc_no_output;

	/* Print each ban */
	for (gIter = scheduler->placement_constraints;
	gIter != NULL; gIter = gIter->next) {
	pcmk__location_t *location = gIter->data;
	const pcmk_resource_t *rsc = location->rsc;

	if (prefix != NULL && !g_str_has_prefix(location->id, prefix)) {
	continue;
	}

	if (!pcmk__str_in_list(rsc_printable_id(rsc), only_rsc,
	pcmk__str_star_matches)
	&& !pcmk__str_in_list(rsc_printable_id(pe__const_top_resource(rsc, false)),
	only_rsc, pcmk__str_star_matches)) {
	continue;
	}

	for (gIter2 = location->nodes; gIter2 != NULL; gIter2 = gIter2->next) {
	pcmk_node_t node = (pcmk_node_t ) gIter2->data;

	if (node->assign->score < 0) {
	PCMK__OUTPUT_LIST_HEADER(out, print_spacer, rc, "Negative Location Constraints");
	out->message(out, "ban", node, location, show_opts);
	}
	}
	}

	PCMK__OUTPUT_LIST_FOOTER(out, rc);
	return rc;
	}

	PCMK__OUTPUT_ARGS("cluster-counts", "unsigned int", "int", "int", "int")
	static int
	cluster_counts_html(pcmk__output_t *out, va_list args) {
	unsigned int nnodes = va_arg(args, unsigned int);
	int nresources = va_arg(args, int);
	int ndisabled = va_arg(args, int);
	int nblocked = va_arg(args, int);

	xmlNodePtr nodes_node = pcmk__output_create_xml_node(out, "li", NULL);
	xmlNodePtr resources_node = pcmk__output_create_xml_node(out, "li", NULL);
	xmlNode *child = NULL;

	child = pcmk__html_create(nodes_node, PCMK__XE_SPAN, NULL, NULL);
	pcmk__xe_set_content(child, "%d node%s configured",
	nnodes, pcmk__plural_s(nnodes));

	if (ndisabled && nblocked) {
	child = pcmk__html_create(resources_node, PCMK__XE_SPAN, NULL, NULL);
	pcmk__xe_set_content(child, "%d resource instance%s configured (%d ",
	nresources, pcmk__plural_s(nresources), ndisabled);

	child = pcmk__html_create(resources_node, PCMK__XE_SPAN, NULL,
	PCMK__VALUE_BOLD);
	pcmk__xe_set_content(child, "DISABLED");

	child = pcmk__html_create(resources_node, PCMK__XE_SPAN, NULL, NULL);
	pcmk__xe_set_content(child, ", %d ", nblocked);

	child = pcmk__html_create(resources_node, PCMK__XE_SPAN, NULL,
	PCMK__VALUE_BOLD);
	pcmk__xe_set_content(child, "BLOCKED");

	child = pcmk__html_create(resources_node, PCMK__XE_SPAN, NULL, NULL);
	pcmk__xe_set_content(child, " from further action due to failure)");

	} else if (ndisabled && !nblocked) {
	child = pcmk__html_create(resources_node, PCMK__XE_SPAN, NULL, NULL);
	pcmk__xe_set_content(child, "%d resource instance%s configured (%d ",
	nresources, pcmk__plural_s(nresources),
	ndisabled);

	child = pcmk__html_create(resources_node, PCMK__XE_SPAN, NULL,
	PCMK__VALUE_BOLD);
	pcmk__xe_set_content(child, "DISABLED");

	child = pcmk__html_create(resources_node, PCMK__XE_SPAN, NULL, NULL);
	pcmk__xe_set_content(child, ")");

	} else if (!ndisabled && nblocked) {
	child = pcmk__html_create(resources_node, PCMK__XE_SPAN, NULL, NULL);
	pcmk__xe_set_content(child, "%d resource instance%s configured (%d ",
	nresources, pcmk__plural_s(nresources),
	nblocked);

	child = pcmk__html_create(resources_node, PCMK__XE_SPAN, NULL,
	PCMK__VALUE_BOLD);
	pcmk__xe_set_content(child, "BLOCKED");

	child = pcmk__html_create(resources_node, PCMK__XE_SPAN, NULL, NULL);
	pcmk__xe_set_content(child, " from further action due to failure)");

	} else {
	child = pcmk__html_create(resources_node, PCMK__XE_SPAN, NULL, NULL);
	pcmk__xe_set_content(child, "%d resource instance%s configured",
	nresources, pcmk__plural_s(nresources));
	}

	return pcmk_rc_ok;
	}

	PCMK__OUTPUT_ARGS("cluster-counts", "unsigned int", "int", "int", "int")
	static int
	cluster_counts_text(pcmk__output_t *out, va_list args) {
	unsigned int nnodes = va_arg(args, unsigned int);
	int nresources = va_arg(args, int);
	int ndisabled = va_arg(args, int);
	int nblocked = va_arg(args, int);

	out->list_item(out, NULL, "%d node%s configured",
	nnodes, pcmk__plural_s(nnodes));

	if (ndisabled && nblocked) {
	out->list_item(out, NULL, "%d resource instance%s configured "
	"(%d DISABLED, %d BLOCKED from "
	"further action due to failure)",
	nresources, pcmk__plural_s(nresources), ndisabled,
	nblocked);
	} else if (ndisabled && !nblocked) {
	out->list_item(out, NULL, "%d resource instance%s configured "
	"(%d DISABLED)",
	nresources, pcmk__plural_s(nresources), ndisabled);
	} else if (!ndisabled && nblocked) {
	out->list_item(out, NULL, "%d resource instance%s configured "
	"(%d BLOCKED from further action "
	"due to failure)",
	nresources, pcmk__plural_s(nresources), nblocked);
	} else {
	out->list_item(out, NULL, "%d resource instance%s configured",
	nresources, pcmk__plural_s(nresources));
	}

	return pcmk_rc_ok;
	}

	PCMK__OUTPUT_ARGS("cluster-counts", "unsigned int", "int", "int", "int")
	static int
	cluster_counts_xml(pcmk__output_t *out, va_list args) {
	unsigned int nnodes = va_arg(args, unsigned int);
	int nresources = va_arg(args, int);
	int ndisabled = va_arg(args, int);
	int nblocked = va_arg(args, int);

	xmlNodePtr nodes_node = NULL;
	xmlNodePtr resources_node = NULL;
	char *s = NULL;

	nodes_node = pcmk__output_create_xml_node(out, PCMK_XE_NODES_CONFIGURED,
	NULL);
	resources_node = pcmk__output_create_xml_node(out,
	PCMK_XE_RESOURCES_CONFIGURED,
	NULL);

	s = pcmk__itoa(nnodes);
	crm_xml_add(nodes_node, PCMK_XA_NUMBER, s);
	free(s);

	s = pcmk__itoa(nresources);
	crm_xml_add(resources_node, PCMK_XA_NUMBER, s);
	free(s);

	s = pcmk__itoa(ndisabled);
	crm_xml_add(resources_node, PCMK_XA_DISABLED, s);
	free(s);

	s = pcmk__itoa(nblocked);
	crm_xml_add(resources_node, PCMK_XA_BLOCKED, s);
	free(s);

	return pcmk_rc_ok;
	}

	PCMK__OUTPUT_ARGS("cluster-dc", "pcmk_node_t ", "const char ", "const char *",
	"char *", "int")
	static int
	cluster_dc_html(pcmk__output_t *out, va_list args) {
	pcmk_node_t dc = va_arg(args, pcmk_node_t );
	const char quorum = va_arg(args, const char );
	const char dc_version_s = va_arg(args, const char );
	char dc_name = va_arg(args, char );
	bool mixed_version = va_arg(args, int);

	xmlNodePtr node = pcmk__output_create_xml_node(out, "li", NULL);
	xmlNode *child = NULL;

	child = pcmk__html_create(node, PCMK__XE_SPAN, NULL, PCMK__VALUE_BOLD);
	pcmk__xe_set_content(child, "Current DC: ");

	if (dc) {
	child = pcmk__html_create(node, PCMK__XE_SPAN, NULL, NULL);
	pcmk__xe_set_content(child, "%s (version %s) -",
	dc_name, pcmk__s(dc_version_s, "unknown"));

	if (mixed_version) {
	child = pcmk__html_create(node, PCMK__XE_SPAN, NULL,
	PCMK__VALUE_WARNING);
	pcmk__xe_set_content(child, " MIXED-VERSION");
	}

	child = pcmk__html_create(node, PCMK__XE_SPAN, NULL, NULL);
	pcmk__xe_set_content(child, " partition");

	if (crm_is_true(quorum)) {
	child = pcmk__html_create(node, PCMK__XE_SPAN, NULL, NULL);
	pcmk__xe_set_content(child, " with");

	} else {
	child = pcmk__html_create(node, PCMK__XE_SPAN, NULL,
	PCMK__VALUE_WARNING);
	pcmk__xe_set_content(child, " WITHOUT");
	}

	child = pcmk__html_create(node, PCMK__XE_SPAN, NULL, NULL);
	pcmk__xe_set_content(child, " quorum");

	} else {
	child = pcmk__html_create(node, PCMK__XE_SPAN, NULL,
	PCMK__VALUE_WARNING);
	pcmk__xe_set_content(child, "NONE");
	}

	return pcmk_rc_ok;
	}

	PCMK__OUTPUT_ARGS("cluster-dc", "pcmk_node_t ", "const char ", "const char *",
	"char *", "int")
	static int
	cluster_dc_text(pcmk__output_t *out, va_list args) {
	pcmk_node_t dc = va_arg(args, pcmk_node_t );
	const char quorum = va_arg(args, const char );
	const char dc_version_s = va_arg(args, const char );
	char dc_name = va_arg(args, char );
	bool mixed_version = va_arg(args, int);

	if (dc) {
	out->list_item(out, "Current DC",
	"%s (version %s) - %spartition %s quorum",
	dc_name, dc_version_s ? dc_version_s : "unknown",
	mixed_version ? "MIXED-VERSION " : "",
	crm_is_true(quorum) ? "with" : "WITHOUT");
	} else {
	out->list_item(out, "Current DC", "NONE");
	}

	return pcmk_rc_ok;
	}

	PCMK__OUTPUT_ARGS("cluster-dc", "pcmk_node_t ", "const char ", "const char *",
	"char *", "int")
	static int
	cluster_dc_xml(pcmk__output_t *out, va_list args) {
	pcmk_node_t dc = va_arg(args, pcmk_node_t );
	const char quorum = va_arg(args, const char );
	const char dc_version_s = va_arg(args, const char );
	char dc_name G_GNUC_UNUSED = va_arg(args, char );
	bool mixed_version = va_arg(args, int);

	if (dc) {
	const char *with_quorum = pcmk__btoa(crm_is_true(quorum));
	const char *mixed_version_s = pcmk__btoa(mixed_version);

	pcmk__output_create_xml_node(out, PCMK_XE_CURRENT_DC,
	PCMK_XA_PRESENT, PCMK_VALUE_TRUE,
	PCMK_XA_VERSION, pcmk__s(dc_version_s, ""),
	PCMK_XA_NAME, dc->private->name,
	PCMK_XA_ID, dc->private->id,
	PCMK_XA_WITH_QUORUM, with_quorum,
	PCMK_XA_MIXED_VERSION, mixed_version_s,
	NULL);
	} else {
	pcmk__output_create_xml_node(out, PCMK_XE_CURRENT_DC,
	PCMK_XA_PRESENT, PCMK_VALUE_FALSE,
	NULL);
	}

	return pcmk_rc_ok;
	}

	PCMK__OUTPUT_ARGS("maint-mode", "unsigned long long int")
	static int
	cluster_maint_mode_text(pcmk__output_t *out, va_list args) {
	unsigned long long flags = va_arg(args, unsigned long long);

	if (pcmk_is_set(flags, pcmk_sched_in_maintenance)) {
	pcmk__formatted_printf(out, "\n * Resource management is DISABLED *\n");
	pcmk__formatted_printf(out, " The cluster will not attempt to start, stop or recover services\n");
	return pcmk_rc_ok;
	} else if (pcmk_is_set(flags, pcmk_sched_stop_all)) {
	pcmk__formatted_printf(out, "\n * Resource management is DISABLED *\n");
	pcmk__formatted_printf(out, " The cluster will keep all resources stopped\n");
	return pcmk_rc_ok;
	} else {
	return pcmk_rc_no_output;
	}
	}

	PCMK__OUTPUT_ARGS("cluster-options", "pcmk_scheduler_t *")
	static int
	cluster_options_html(pcmk__output_t *out, va_list args) {
	pcmk_scheduler_t scheduler = va_arg(args, pcmk_scheduler_t );

	if (pcmk_is_set(scheduler->flags, pcmk_sched_fencing_enabled)) {
	out->list_item(out, NULL, "STONITH of failed nodes enabled");
	} else {
	out->list_item(out, NULL, "STONITH of failed nodes disabled");
	}

	if (pcmk_is_set(scheduler->flags, pcmk_sched_symmetric_cluster)) {
	out->list_item(out, NULL, "Cluster is symmetric");
	} else {
	out->list_item(out, NULL, "Cluster is asymmetric");
	}

	switch (scheduler->no_quorum_policy) {
	case pcmk_no_quorum_freeze:
	out->list_item(out, NULL, "No quorum policy: Freeze resources");
	break;

	case pcmk_no_quorum_stop:
	out->list_item(out, NULL, "No quorum policy: Stop ALL resources");
	break;

	case pcmk_no_quorum_demote:
	out->list_item(out, NULL, "No quorum policy: Demote promotable "
	"resources and stop all other resources");
	break;

	case pcmk_no_quorum_ignore:
	out->list_item(out, NULL, "No quorum policy: Ignore");
	break;

	case pcmk_no_quorum_fence:
	out->list_item(out, NULL, "No quorum policy: Suicide");
	break;
	}

	if (pcmk_is_set(scheduler->flags, pcmk_sched_in_maintenance)) {
	xmlNodePtr node = pcmk__output_create_xml_node(out, "li", NULL);
	xmlNode *child = NULL;

	child = pcmk__html_create(node, PCMK__XE_SPAN, NULL, NULL);
	pcmk__xe_set_content(child, "Resource management: ");

	child = pcmk__html_create(node, PCMK__XE_SPAN, NULL, PCMK__VALUE_BOLD);
	pcmk__xe_set_content(child, "DISABLED");

	child = pcmk__html_create(node, PCMK__XE_SPAN, NULL, NULL);
	pcmk__xe_set_content(child,
	" (the cluster will not attempt to start, stop,"
	" or recover services)");

	} else if (pcmk_is_set(scheduler->flags, pcmk_sched_stop_all)) {
	xmlNodePtr node = pcmk__output_create_xml_node(out, "li", NULL);
	xmlNode *child = NULL;

	child = pcmk__html_create(node, PCMK__XE_SPAN, NULL, NULL);
	pcmk__xe_set_content(child, "Resource management: ");

	child = pcmk__html_create(node, PCMK__XE_SPAN, NULL, PCMK__VALUE_BOLD);
	pcmk__xe_set_content(child, "STOPPED");

	child = pcmk__html_create(node, PCMK__XE_SPAN, NULL, NULL);
	pcmk__xe_set_content(child,
	" (the cluster will keep all resources stopped)");

	} else {
	out->list_item(out, NULL, "Resource management: enabled");
	}

	return pcmk_rc_ok;
	}

	PCMK__OUTPUT_ARGS("cluster-options", "pcmk_scheduler_t *")
	static int
	cluster_options_log(pcmk__output_t *out, va_list args) {
	pcmk_scheduler_t scheduler = va_arg(args, pcmk_scheduler_t );

	if (pcmk_is_set(scheduler->flags, pcmk_sched_in_maintenance)) {
	return out->info(out, "Resource management is DISABLED. The cluster will not attempt to start, stop or recover services.");
	} else if (pcmk_is_set(scheduler->flags, pcmk_sched_stop_all)) {
	return out->info(out, "Resource management is DISABLED. The cluster has stopped all resources.");
	} else {
	return pcmk_rc_no_output;
	}
	}

	PCMK__OUTPUT_ARGS("cluster-options", "pcmk_scheduler_t *")
	static int
	cluster_options_text(pcmk__output_t *out, va_list args) {
	pcmk_scheduler_t scheduler = va_arg(args, pcmk_scheduler_t );

	if (pcmk_is_set(scheduler->flags, pcmk_sched_fencing_enabled)) {
	out->list_item(out, NULL, "STONITH of failed nodes enabled");
	} else {
	out->list_item(out, NULL, "STONITH of failed nodes disabled");
	}

	if (pcmk_is_set(scheduler->flags, pcmk_sched_symmetric_cluster)) {
	out->list_item(out, NULL, "Cluster is symmetric");
	} else {
	out->list_item(out, NULL, "Cluster is asymmetric");
	}

	switch (scheduler->no_quorum_policy) {
	case pcmk_no_quorum_freeze:
	out->list_item(out, NULL, "No quorum policy: Freeze resources");
	break;

	case pcmk_no_quorum_stop:
	out->list_item(out, NULL, "No quorum policy: Stop ALL resources");
	break;

	case pcmk_no_quorum_demote:
	out->list_item(out, NULL, "No quorum policy: Demote promotable "
	"resources and stop all other resources");
	break;

	case pcmk_no_quorum_ignore:
	out->list_item(out, NULL, "No quorum policy: Ignore");
	break;

	case pcmk_no_quorum_fence:
	out->list_item(out, NULL, "No quorum policy: Suicide");
	break;
	}

	return pcmk_rc_ok;
	}

	/*!
	* \internal
	* \brief Get readable string representation of a no-quorum policy
	*
	* \param[in] policy No-quorum policy
	*
	* \return String representation of \p policy
	*/
	static const char *
	no_quorum_policy_text(enum pe_quorum_policy policy)
	{
	switch (policy) {
	case pcmk_no_quorum_freeze:
	return PCMK_VALUE_FREEZE;

	case pcmk_no_quorum_stop:
	return PCMK_VALUE_STOP;

	case pcmk_no_quorum_demote:
	return PCMK_VALUE_DEMOTE;

	case pcmk_no_quorum_ignore:
	return PCMK_VALUE_IGNORE;

	case pcmk_no_quorum_fence:
	return PCMK_VALUE_FENCE_LEGACY;

	default:
	return PCMK_VALUE_UNKNOWN;
	}
	}

	PCMK__OUTPUT_ARGS("cluster-options", "pcmk_scheduler_t *")
	static int
	cluster_options_xml(pcmk__output_t *out, va_list args) {
	pcmk_scheduler_t scheduler = va_arg(args, pcmk_scheduler_t );

	const char *stonith_enabled = pcmk__flag_text(scheduler->flags,
	pcmk_sched_fencing_enabled);
	const char *symmetric_cluster =
	pcmk__flag_text(scheduler->flags, pcmk_sched_symmetric_cluster);
	const char *no_quorum_policy =
	no_quorum_policy_text(scheduler->no_quorum_policy);
	const char *maintenance_mode = pcmk__flag_text(scheduler->flags,
	pcmk_sched_in_maintenance);
	const char *stop_all_resources = pcmk__flag_text(scheduler->flags,
	pcmk_sched_stop_all);
	char *stonith_timeout_ms_s = pcmk__itoa(scheduler->stonith_timeout);
	char *priority_fencing_delay_ms_s =
	pcmk__itoa(scheduler->priority_fencing_delay * 1000);

	pcmk__output_create_xml_node(out, PCMK_XE_CLUSTER_OPTIONS,
	PCMK_XA_STONITH_ENABLED, stonith_enabled,
	PCMK_XA_SYMMETRIC_CLUSTER, symmetric_cluster,
	PCMK_XA_NO_QUORUM_POLICY, no_quorum_policy,
	PCMK_XA_MAINTENANCE_MODE, maintenance_mode,
	PCMK_XA_STOP_ALL_RESOURCES, stop_all_resources,
	PCMK_XA_STONITH_TIMEOUT_MS,
	stonith_timeout_ms_s,
	PCMK_XA_PRIORITY_FENCING_DELAY_MS,
	priority_fencing_delay_ms_s,
	NULL);
	free(stonith_timeout_ms_s);
	free(priority_fencing_delay_ms_s);

	return pcmk_rc_ok;
	}

	PCMK__OUTPUT_ARGS("cluster-stack", "const char *", "enum pcmk_pacemakerd_state")
	static int
	cluster_stack_html(pcmk__output_t *out, va_list args) {
	const char stack_s = va_arg(args, const char );
	enum pcmk_pacemakerd_state pcmkd_state =
	(enum pcmk_pacemakerd_state) va_arg(args, int);

	xmlNodePtr node = pcmk__output_create_xml_node(out, "li", NULL);
	xmlNode *child = NULL;

	child = pcmk__html_create(node, PCMK__XE_SPAN, NULL, PCMK__VALUE_BOLD);
	pcmk__xe_set_content(child, "Stack: ");

	child = pcmk__html_create(node, PCMK__XE_SPAN, NULL, NULL);
	pcmk__xe_set_content(child, "%s", stack_s);

	if (pcmkd_state != pcmk_pacemakerd_state_invalid) {
	child = pcmk__html_create(node, PCMK__XE_SPAN, NULL, NULL);
	pcmk__xe_set_content(child, " (");

	child = pcmk__html_create(node, PCMK__XE_SPAN, NULL, NULL);
	pcmk__xe_set_content(child, "%s",
	pcmk__pcmkd_state_enum2friendly(pcmkd_state));

	child = pcmk__html_create(node, PCMK__XE_SPAN, NULL, NULL);
	pcmk__xe_set_content(child, ")");
	}
	return pcmk_rc_ok;
	}

	PCMK__OUTPUT_ARGS("cluster-stack", "const char *", "enum pcmk_pacemakerd_state")
	static int
	cluster_stack_text(pcmk__output_t *out, va_list args) {
	const char stack_s = va_arg(args, const char );
	enum pcmk_pacemakerd_state pcmkd_state =
	(enum pcmk_pacemakerd_state) va_arg(args, int);

	if (pcmkd_state != pcmk_pacemakerd_state_invalid) {
	out->list_item(out, "Stack", "%s (%s)",
	stack_s, pcmk__pcmkd_state_enum2friendly(pcmkd_state));
	} else {
	out->list_item(out, "Stack", "%s", stack_s);
	}

	return pcmk_rc_ok;
	}

	PCMK__OUTPUT_ARGS("cluster-stack", "const char *", "enum pcmk_pacemakerd_state")
	static int
	cluster_stack_xml(pcmk__output_t *out, va_list args) {
	const char stack_s = va_arg(args, const char );
	enum pcmk_pacemakerd_state pcmkd_state =
	(enum pcmk_pacemakerd_state) va_arg(args, int);

	const char *state_s = NULL;

	if (pcmkd_state != pcmk_pacemakerd_state_invalid) {
	state_s = pcmk_pacemakerd_api_daemon_state_enum2text(pcmkd_state);
	}

	pcmk__output_create_xml_node(out, PCMK_XE_STACK,
	PCMK_XA_TYPE, stack_s,
	PCMK_XA_PACEMAKERD_STATE, state_s,
	NULL);

	return pcmk_rc_ok;
	}

	PCMK__OUTPUT_ARGS("cluster-times", "const char ", "const char ",
	"const char ", "const char ", "const char *")
	static int
	cluster_times_html(pcmk__output_t *out, va_list args) {
	const char our_nodename = va_arg(args, const char );
	const char last_written = va_arg(args, const char );
	const char user = va_arg(args, const char );
	const char client = va_arg(args, const char );
	const char origin = va_arg(args, const char );

	xmlNodePtr updated_node = pcmk__output_create_xml_node(out, "li", NULL);
	xmlNodePtr changed_node = pcmk__output_create_xml_node(out, "li", NULL);
	xmlNode *child = NULL;

	char *time_s = NULL;

	child = pcmk__html_create(updated_node, PCMK__XE_SPAN, NULL,
	PCMK__VALUE_BOLD);
	pcmk__xe_set_content(child, "Last updated: ");

	child = pcmk__html_create(updated_node, PCMK__XE_SPAN, NULL, NULL);
	time_s = pcmk__epoch2str(NULL, 0);
	pcmk__xe_set_content(child, "%s", time_s);
	free(time_s);

	if (our_nodename != NULL) {
	child = pcmk__html_create(updated_node, PCMK__XE_SPAN, NULL, NULL);
	pcmk__xe_set_content(child, " on ");

	child = pcmk__html_create(updated_node, PCMK__XE_SPAN, NULL, NULL);
	pcmk__xe_set_content(child, "%s", our_nodename);
	}

	child = pcmk__html_create(changed_node, PCMK__XE_SPAN, NULL,
	PCMK__VALUE_BOLD);
	pcmk__xe_set_content(child, "Last change: ");

	child = pcmk__html_create(changed_node, PCMK__XE_SPAN, NULL, NULL);
	time_s = last_changed_string(last_written, user, client, origin);
	pcmk__xe_set_content(child, "%s", time_s);
	free(time_s);

	return pcmk_rc_ok;
	}

	PCMK__OUTPUT_ARGS("cluster-times", "const char ", "const char ",
	"const char ", "const char ", "const char *")
	static int
	cluster_times_xml(pcmk__output_t *out, va_list args) {
	const char our_nodename = va_arg(args, const char );
	const char last_written = va_arg(args, const char );
	const char user = va_arg(args, const char );
	const char client = va_arg(args, const char );
	const char origin = va_arg(args, const char );

	char *time_s = pcmk__epoch2str(NULL, 0);

	pcmk__output_create_xml_node(out, PCMK_XE_LAST_UPDATE,
	PCMK_XA_TIME, time_s,
	PCMK_XA_ORIGIN, our_nodename,
	NULL);

	pcmk__output_create_xml_node(out, PCMK_XE_LAST_CHANGE,
	PCMK_XA_TIME, pcmk__s(last_written, ""),
	PCMK_XA_USER, pcmk__s(user, ""),
	PCMK_XA_CLIENT, pcmk__s(client, ""),
	PCMK_XA_ORIGIN, pcmk__s(origin, ""),
	NULL);

	free(time_s);
	return pcmk_rc_ok;
	}

	PCMK__OUTPUT_ARGS("cluster-times", "const char ", "const char ",
	"const char ", "const char ", "const char *")
	static int
	cluster_times_text(pcmk__output_t *out, va_list args) {
	const char our_nodename = va_arg(args, const char );
	const char last_written = va_arg(args, const char );
	const char user = va_arg(args, const char );
	const char client = va_arg(args, const char );
	const char origin = va_arg(args, const char );

	char *time_s = pcmk__epoch2str(NULL, 0);

	out->list_item(out, "Last updated", "%s%s%s",
	time_s, (our_nodename != NULL)? " on " : "",
	pcmk__s(our_nodename, ""));

	free(time_s);
	time_s = last_changed_string(last_written, user, client, origin);

	out->list_item(out, "Last change", " %s", time_s);

	free(time_s);
	return pcmk_rc_ok;
	}

	/*!
	* \internal
	* \brief Display a failed action in less-technical natural language
	*
	* \param[in,out] out Output object to use for display
	* \param[in] xml_op XML containing failed action
	* \param[in] op_key Operation key of failed action
	* \param[in] node_name Where failed action occurred
	* \param[in] rc OCF exit code of failed action
	* \param[in] status Execution status of failed action
	* \param[in] exit_reason Exit reason given for failed action
	* \param[in] exec_time String containing execution time in milliseconds
	*/
	static void
	failed_action_friendly(pcmk__output_t out, const xmlNode xml_op,
	const char op_key, const char node_name, int rc,
	int status, const char *exit_reason,
	const char *exec_time)
	{
	char *rsc_id = NULL;
	char *task = NULL;
	guint interval_ms = 0;
	time_t last_change_epoch = 0;
	GString *str = NULL;

	if (pcmk__str_empty(op_key)
	\|\| !parse_op_key(op_key, &rsc_id, &task, &interval_ms)) {

	pcmk__str_update(&rsc_id, "unknown resource");
	pcmk__str_update(&task, "unknown action");
	interval_ms = 0;
	}
	CRM_ASSERT((rsc_id != NULL) && (task != NULL));

	str = g_string_sized_new(256); // Should be sufficient for most messages

	pcmk__g_strcat(str, rsc_id, " ", NULL);

	if (interval_ms != 0) {
	pcmk__g_strcat(str, pcmk__readable_interval(interval_ms), "-interval ",
	NULL);
	}
	pcmk__g_strcat(str, pcmk__readable_action(task, interval_ms), " on ",
	node_name, NULL);

	if (status == PCMK_EXEC_DONE) {
	pcmk__g_strcat(str, " returned '", services_ocf_exitcode_str(rc), "'",
	NULL);
	if (!pcmk__str_empty(exit_reason)) {
	pcmk__g_strcat(str, " (", exit_reason, ")", NULL);
	}

	} else {
	pcmk__g_strcat(str, " could not be executed (",
	pcmk_exec_status_str(status), NULL);
	if (!pcmk__str_empty(exit_reason)) {
	pcmk__g_strcat(str, ": ", exit_reason, NULL);
	}
	g_string_append_c(str, ')');
	}


	if (crm_element_value_epoch(xml_op, PCMK_XA_LAST_RC_CHANGE,
	&last_change_epoch) == pcmk_ok) {
	char *s = pcmk__epoch2str(&last_change_epoch, 0);

	pcmk__g_strcat(str, " at ", s, NULL);
	free(s);
	}
	if (!pcmk__str_empty(exec_time)) {
	int exec_time_ms = 0;

	if ((pcmk__scan_min_int(exec_time, &exec_time_ms, 0) == pcmk_rc_ok)
	&& (exec_time_ms > 0)) {

	pcmk__g_strcat(str, " after ",
	pcmk__readable_interval(exec_time_ms), NULL);
	}
	}

	out->list_item(out, NULL, "%s", str->str);
	g_string_free(str, TRUE);
	free(rsc_id);
	free(task);
	}

	/*!
	* \internal
	* \brief Display a failed action with technical details
	*
	* \param[in,out] out Output object to use for display
	* \param[in] xml_op XML containing failed action
	* \param[in] op_key Operation key of failed action
	* \param[in] node_name Where failed action occurred
	* \param[in] rc OCF exit code of failed action
	* \param[in] status Execution status of failed action
	* \param[in] exit_reason Exit reason given for failed action
	* \param[in] exec_time String containing execution time in milliseconds
	*/
	static void
	failed_action_technical(pcmk__output_t out, const xmlNode xml_op,
	const char op_key, const char node_name, int rc,
	int status, const char *exit_reason,
	const char *exec_time)
	{
	const char *call_id = crm_element_value(xml_op, PCMK__XA_CALL_ID);
	const char *queue_time = crm_element_value(xml_op, PCMK_XA_QUEUE_TIME);
	const char *exit_status = services_ocf_exitcode_str(rc);
	const char *lrm_status = pcmk_exec_status_str(status);
	time_t last_change_epoch = 0;
	GString *str = NULL;

	if (pcmk__str_empty(op_key)) {
	op_key = "unknown operation";
	}
	if (pcmk__str_empty(exit_status)) {
	exit_status = "unknown exit status";
	}
	if (pcmk__str_empty(call_id)) {
	call_id = "unknown";
	}

	str = g_string_sized_new(256);

	g_string_append_printf(str, "%s on %s '%s' (%d): call=%s, status='%s'",
	op_key, node_name, exit_status, rc, call_id,
	lrm_status);

	if (!pcmk__str_empty(exit_reason)) {
	pcmk__g_strcat(str, ", exitreason='", exit_reason, "'", NULL);
	}

	if (crm_element_value_epoch(xml_op, PCMK_XA_LAST_RC_CHANGE,
	&last_change_epoch) == pcmk_ok) {
	char *last_change_str = pcmk__epoch2str(&last_change_epoch, 0);

	pcmk__g_strcat(str,
	", " PCMK_XA_LAST_RC_CHANGE "="
	"'", last_change_str, "'", NULL);
	free(last_change_str);
	}
	if (!pcmk__str_empty(queue_time)) {
	pcmk__g_strcat(str, ", queued=", queue_time, "ms", NULL);
	}
	if (!pcmk__str_empty(exec_time)) {
	pcmk__g_strcat(str, ", exec=", exec_time, "ms", NULL);
	}

	out->list_item(out, NULL, "%s", str->str);
	g_string_free(str, TRUE);
	}

	PCMK__OUTPUT_ARGS("failed-action", "xmlNode *", "uint32_t")
	static int
	failed_action_default(pcmk__output_t *out, va_list args)
	{
	xmlNodePtr xml_op = va_arg(args, xmlNodePtr);
	uint32_t show_opts = va_arg(args, uint32_t);

	const char *op_key = pcmk__xe_history_key(xml_op);
	const char *node_name = crm_element_value(xml_op, PCMK_XA_UNAME);
	const char *exit_reason = crm_element_value(xml_op, PCMK_XA_EXIT_REASON);
	const char *exec_time = crm_element_value(xml_op, PCMK_XA_EXEC_TIME);

	int rc;
	int status;

	pcmk__scan_min_int(crm_element_value(xml_op, PCMK__XA_RC_CODE), &rc, 0);

	pcmk__scan_min_int(crm_element_value(xml_op, PCMK__XA_OP_STATUS), &status,
	0);

	if (pcmk__str_empty(node_name)) {
	node_name = "unknown node";
	}

	if (pcmk_is_set(show_opts, pcmk_show_failed_detail)) {
	failed_action_technical(out, xml_op, op_key, node_name, rc, status,
	exit_reason, exec_time);
	} else {
	failed_action_friendly(out, xml_op, op_key, node_name, rc, status,
	exit_reason, exec_time);
	}
	return pcmk_rc_ok;
	}

	PCMK__OUTPUT_ARGS("failed-action", "xmlNode *", "uint32_t")
	static int
	failed_action_xml(pcmk__output_t *out, va_list args) {
	xmlNodePtr xml_op = va_arg(args, xmlNodePtr);
	uint32_t show_opts G_GNUC_UNUSED = va_arg(args, uint32_t);

	const char *op_key = pcmk__xe_history_key(xml_op);
	const char *op_key_name = PCMK_XA_OP_KEY;
	int rc;
	int status;
	const char *uname = crm_element_value(xml_op, PCMK_XA_UNAME);
	const char *call_id = crm_element_value(xml_op, PCMK__XA_CALL_ID);
	const char *exitstatus = NULL;
	const char *exit_reason = pcmk__s(crm_element_value(xml_op,
	PCMK_XA_EXIT_REASON),
	"none");
	const char *status_s = NULL;

	time_t epoch = 0;
	gchar *exit_reason_esc = NULL;
	char *rc_s = NULL;
	xmlNodePtr node = NULL;

	if (pcmk__xml_needs_escape(exit_reason, pcmk__xml_escape_attr)) {
	exit_reason_esc = pcmk__xml_escape(exit_reason, pcmk__xml_escape_attr);
	exit_reason = exit_reason_esc;
	}
	pcmk__scan_min_int(crm_element_value(xml_op, PCMK__XA_RC_CODE), &rc, 0);
	pcmk__scan_min_int(crm_element_value(xml_op, PCMK__XA_OP_STATUS), &status,
	0);

	if (crm_element_value(xml_op, PCMK__XA_OPERATION_KEY) == NULL) {
	op_key_name = PCMK_XA_ID;
	}
	exitstatus = services_ocf_exitcode_str(rc);
	rc_s = pcmk__itoa(rc);
	status_s = pcmk_exec_status_str(status);
	node = pcmk__output_create_xml_node(out, PCMK_XE_FAILURE,
	op_key_name, op_key,
	PCMK_XA_NODE, uname,
	PCMK_XA_EXITSTATUS, exitstatus,
	PCMK_XA_EXITREASON, exit_reason,
	PCMK_XA_EXITCODE, rc_s,
	PCMK_XA_CALL, call_id,
	PCMK_XA_STATUS, status_s,
	NULL);
	free(rc_s);

	if ((crm_element_value_epoch(xml_op, PCMK_XA_LAST_RC_CHANGE,
	&epoch) == pcmk_ok) && (epoch > 0)) {

	const char *queue_time = crm_element_value(xml_op, PCMK_XA_QUEUE_TIME);
	const char *exec = crm_element_value(xml_op, PCMK_XA_EXEC_TIME);
	const char *task = crm_element_value(xml_op, PCMK_XA_OPERATION);
	guint interval_ms = 0;
	char *interval_ms_s = NULL;
	char *rc_change = pcmk__epoch2str(&epoch,
	crm_time_log_date
	\|crm_time_log_timeofday
	\|crm_time_log_with_timezone);

	crm_element_value_ms(xml_op, PCMK_META_INTERVAL, &interval_ms);
	interval_ms_s = crm_strdup_printf("%u", interval_ms);

	pcmk__xe_set_props(node,
	PCMK_XA_LAST_RC_CHANGE, rc_change,
	PCMK_XA_QUEUED, queue_time,
	PCMK_XA_EXEC, exec,
	PCMK_XA_INTERVAL, interval_ms_s,
	PCMK_XA_TASK, task,
	NULL);

	free(interval_ms_s);
	free(rc_change);
	}

	g_free(exit_reason_esc);
	return pcmk_rc_ok;
	}

	PCMK__OUTPUT_ARGS("failed-action-list", "pcmk_scheduler_t ", "GList ",
	"GList *", "uint32_t", "bool")
	static int
	failed_action_list(pcmk__output_t *out, va_list args) {
	pcmk_scheduler_t scheduler = va_arg(args, pcmk_scheduler_t );
	GList only_node = va_arg(args, GList );
	GList only_rsc = va_arg(args, GList );
	uint32_t show_opts = va_arg(args, uint32_t);
	bool print_spacer = va_arg(args, int);

	xmlNode *xml_op = NULL;
	int rc = pcmk_rc_no_output;

	if (xmlChildElementCount(scheduler->failed) == 0) {
	return rc;
	}

	for (xml_op = pcmk__xe_first_child(scheduler->failed, NULL, NULL, NULL);
	xml_op != NULL; xml_op = pcmk__xe_next(xml_op)) {

	char *rsc = NULL;

	if (!pcmk__str_in_list(crm_element_value(xml_op, PCMK_XA_UNAME),
	only_node,
	pcmk__str_star_matches\|pcmk__str_casei)) {
	continue;
	}

	if (pcmk_xe_mask_probe_failure(xml_op)) {
	continue;
	}

	if (!parse_op_key(pcmk__xe_history_key(xml_op), &rsc, NULL, NULL)) {
	continue;
	}

	if (!pcmk__str_in_list(rsc, only_rsc, pcmk__str_star_matches)) {
	free(rsc);
	continue;
	}

	free(rsc);

	PCMK__OUTPUT_LIST_HEADER(out, print_spacer, rc, "Failed Resource Actions");
	out->message(out, "failed-action", xml_op, show_opts);
	}

	PCMK__OUTPUT_LIST_FOOTER(out, rc);
	return rc;
	}

	static void
	status_node(pcmk_node_t *node, xmlNodePtr parent, uint32_t show_opts)
	{
	int health = pe__node_health(node);
	xmlNode *child = NULL;

	// Cluster membership
	if (node->details->online) {
	child = pcmk__html_create(parent, PCMK__XE_SPAN, NULL,
	PCMK_VALUE_ONLINE);
	pcmk__xe_set_content(child, " online");

	} else {
	child = pcmk__html_create(parent, PCMK__XE_SPAN, NULL,
	PCMK_VALUE_OFFLINE);
	pcmk__xe_set_content(child, " OFFLINE");
	}

	// Standby mode
	if (pcmk_is_set(node->private->flags, pcmk__node_fail_standby)) {
	child = pcmk__html_create(parent, PCMK__XE_SPAN, NULL,
	PCMK_VALUE_STANDBY);
	if (node->details->running_rsc == NULL) {
	pcmk__xe_set_content(child,
	" (in standby due to " PCMK_META_ON_FAIL ")");
	} else {
	pcmk__xe_set_content(child,
	" (in standby due to " PCMK_META_ON_FAIL ","
	" with active resources)");
	}

	} else if (pcmk_is_set(node->private->flags, pcmk__node_standby)) {
	child = pcmk__html_create(parent, PCMK__XE_SPAN, NULL,
	PCMK_VALUE_STANDBY);
	if (node->details->running_rsc == NULL) {
	pcmk__xe_set_content(child, " (in standby)");
	} else {
	pcmk__xe_set_content(child, " (in standby, with active resources)");
	}
	}

	// Maintenance mode
	if (node->details->maintenance) {
	child = pcmk__html_create(parent, PCMK__XE_SPAN, NULL,
	PCMK__VALUE_MAINT);
	pcmk__xe_set_content(child, " (in maintenance mode)");
	}

	// Node health
	if (health < 0) {
	child = pcmk__html_create(parent, PCMK__XE_SPAN, NULL,
	PCMK__VALUE_HEALTH_RED);
	pcmk__xe_set_content(child, " (health is RED)");

	} else if (health == 0) {
	child = pcmk__html_create(parent, PCMK__XE_SPAN, NULL,
	PCMK__VALUE_HEALTH_YELLOW);
	pcmk__xe_set_content(child, " (health is YELLOW)");
	}

	// Feature set
	if (pcmk_is_set(show_opts, pcmk_show_feature_set)) {
	const char *feature_set = get_node_feature_set(node);
	if (feature_set != NULL) {
	child = pcmk__html_create(parent, PCMK__XE_SPAN, NULL, NULL);
	pcmk__xe_set_content(child, ", feature set %s", feature_set);
	}
	}
	}

	PCMK__OUTPUT_ARGS("node", "pcmk_node_t *", "uint32_t", "bool",
	"GList ", "GList ")
	static int
	node_html(pcmk__output_t *out, va_list args) {
	pcmk_node_t node = va_arg(args, pcmk_node_t );
	uint32_t show_opts = va_arg(args, uint32_t);
	bool full = va_arg(args, int);
	GList only_node = va_arg(args, GList );
	GList only_rsc = va_arg(args, GList );

	char *node_name = pe__node_display_name(node, pcmk_is_set(show_opts, pcmk_show_node_id));

	if (full) {
	xmlNode *item_node = NULL;
	xmlNode *child = NULL;

	if (pcmk_all_flags_set(show_opts, pcmk_show_brief \| pcmk_show_rscs_by_node)) {
	GList *rscs = pe__filter_rsc_list(node->details->running_rsc, only_rsc);

	out->begin_list(out, NULL, NULL, "%s:", node_name);
	item_node = pcmk__output_xml_create_parent(out, "li", NULL);
	child = pcmk__html_create(item_node, PCMK__XE_SPAN, NULL, NULL);
	pcmk__xe_set_content(child, "Status:");
	status_node(node, item_node, show_opts);

	if (rscs != NULL) {
	uint32_t new_show_opts = (show_opts \| pcmk_show_rsc_only) & ~pcmk_show_inactive_rscs;
	out->begin_list(out, NULL, NULL, "Resources");
	pe__rscs_brief_output(out, rscs, new_show_opts);
	out->end_list(out);
	}

	pcmk__output_xml_pop_parent(out);
	out->end_list(out);

	} else if (pcmk_is_set(show_opts, pcmk_show_rscs_by_node)) {
	GList *lpc2 = NULL;
	int rc = pcmk_rc_no_output;

	out->begin_list(out, NULL, NULL, "%s:", node_name);
	item_node = pcmk__output_xml_create_parent(out, "li", NULL);
	child = pcmk__html_create(item_node, PCMK__XE_SPAN, NULL, NULL);
	pcmk__xe_set_content(child, "Status:");
	status_node(node, item_node, show_opts);

	for (lpc2 = node->details->running_rsc; lpc2 != NULL; lpc2 = lpc2->next) {
	pcmk_resource_t rsc = (pcmk_resource_t ) lpc2->data;

	PCMK__OUTPUT_LIST_HEADER(out, false, rc, "Resources");

	show_opts \|= pcmk_show_rsc_only;
	out->message(out, pcmk__map_element_name(rsc->private->xml),
	show_opts, rsc, only_node, only_rsc);
	}

	PCMK__OUTPUT_LIST_FOOTER(out, rc);
	pcmk__output_xml_pop_parent(out);
	out->end_list(out);

	} else {
	item_node = pcmk__output_create_xml_node(out, "li", NULL);
	child = pcmk__html_create(item_node, PCMK__XE_SPAN, NULL,
	PCMK__VALUE_BOLD);
	pcmk__xe_set_content(child, "%s:", node_name);
	status_node(node, item_node, show_opts);
	}
	} else {
	out->begin_list(out, NULL, NULL, "%s:", node_name);
	}

	free(node_name);
	return pcmk_rc_ok;
	}

	/*!
	* \internal
	* \brief Get a human-friendly textual description of a node's status
	*
	* \param[in] node Node to check
	*
	* \return String representation of node's status
	*/
	static const char *
	node_text_status(const pcmk_node_t *node)
	{
	if (node->details->unclean) {
	if (node->details->online) {
	return "UNCLEAN (online)";

	} else if (node->details->pending) {
	return "UNCLEAN (pending)";

	} else {
	return "UNCLEAN (offline)";
	}

	} else if (node->details->pending) {
	return "pending";

	} else if (pcmk_is_set(node->private->flags, pcmk__node_fail_standby)
	&& node->details->online) {
	return "standby (" PCMK_META_ON_FAIL ")";

	} else if (pcmk_is_set(node->private->flags, pcmk__node_standby)) {
	if (!node->details->online) {
	return "OFFLINE (standby)";
	} else if (node->details->running_rsc == NULL) {
	return "standby";
	} else {
	return "standby (with active resources)";
	}

	} else if (node->details->maintenance) {
	if (node->details->online) {
	return "maintenance";
	} else {
	return "OFFLINE (maintenance)";
	}

	} else if (node->details->online) {
	return "online";
	}

	return "OFFLINE";
	}

	PCMK__OUTPUT_ARGS("node", "pcmk_node_t ", "uint32_t", "bool", "GList ",
	"GList *")
	static int
	node_text(pcmk__output_t *out, va_list args) {
	pcmk_node_t node = va_arg(args, pcmk_node_t );
	uint32_t show_opts = va_arg(args, uint32_t);
	bool full = va_arg(args, int);
	GList only_node = va_arg(args, GList );
	GList only_rsc = va_arg(args, GList );

	if (full) {
	char *node_name = pe__node_display_name(node, pcmk_is_set(show_opts, pcmk_show_node_id));
	GString *str = g_string_sized_new(64);
	int health = pe__node_health(node);

	// Create a summary line with node type, name, and status
	if (pcmk__is_guest_or_bundle_node(node)) {
	g_string_append(str, "GuestNode");
	} else if (pcmk__is_remote_node(node)) {
	g_string_append(str, "RemoteNode");
	} else {
	g_string_append(str, "Node");
	}
	pcmk__g_strcat(str, " ", node_name, ": ", node_text_status(node), NULL);

	if (health < 0) {
	g_string_append(str, " (health is RED)");
	} else if (health == 0) {
	g_string_append(str, " (health is YELLOW)");
	}
	if (pcmk_is_set(show_opts, pcmk_show_feature_set)) {
	const char *feature_set = get_node_feature_set(node);
	if (feature_set != NULL) {
	pcmk__g_strcat(str, ", feature set ", feature_set, NULL);
	}
	}

	/* If we're grouping by node, print its resources */
	if (pcmk_is_set(show_opts, pcmk_show_rscs_by_node)) {
	if (pcmk_is_set(show_opts, pcmk_show_brief)) {
	GList *rscs = pe__filter_rsc_list(node->details->running_rsc, only_rsc);

	if (rscs != NULL) {
	uint32_t new_show_opts = (show_opts \| pcmk_show_rsc_only) & ~pcmk_show_inactive_rscs;
	out->begin_list(out, NULL, NULL, "%s", str->str);
	out->begin_list(out, NULL, NULL, "Resources");

	pe__rscs_brief_output(out, rscs, new_show_opts);

	out->end_list(out);
	out->end_list(out);

	g_list_free(rscs);
	}

	} else {
	GList *gIter2 = NULL;

	out->begin_list(out, NULL, NULL, "%s", str->str);
	out->begin_list(out, NULL, NULL, "Resources");

	for (gIter2 = node->details->running_rsc; gIter2 != NULL; gIter2 = gIter2->next) {
	pcmk_resource_t rsc = (pcmk_resource_t ) gIter2->data;

	show_opts \|= pcmk_show_rsc_only;
	out->message(out, pcmk__map_element_name(rsc->private->xml),
	show_opts, rsc, only_node, only_rsc);
	}

	out->end_list(out);
	out->end_list(out);
	}
	} else {
	out->list_item(out, NULL, "%s", str->str);
	}

	g_string_free(str, TRUE);
	free(node_name);
	} else {
	char *node_name = pe__node_display_name(node, pcmk_is_set(show_opts, pcmk_show_node_id));
	out->begin_list(out, NULL, NULL, "Node: %s", node_name);
	free(node_name);
	}

	return pcmk_rc_ok;
	}

	/*!
	* \internal
	* \brief Convert an integer health value to a string representation
	*
	* \param[in] health Integer health value
	*
	* \retval \c PCMK_VALUE_RED if \p health is less than 0
	* \retval \c PCMK_VALUE_YELLOW if \p health is equal to 0
	* \retval \c PCMK_VALUE_GREEN if \p health is greater than 0
	*/
	static const char *
	health_text(int health)
	{
	if (health < 0) {
	return PCMK_VALUE_RED;
	} else if (health == 0) {
	return PCMK_VALUE_YELLOW;
	} else {
	return PCMK_VALUE_GREEN;
	}
	}

	/*!
	* \internal
	* \brief Convert a node variant to a string representation
	*
	* \param[in] variant Node variant
	*
	* \retval \c PCMK_VALUE_MEMBER if \p node_type is \c pcmk__node_variant_cluster
	* \retval \c PCMK_VALUE_REMOTE if \p node_type is \c pcmk__node_variant_remote
	* \retval \c PCMK__VALUE_PING if \p node_type is \c pcmk__node_variant_ping
	* \retval \c PCMK_VALUE_UNKNOWN otherwise
	*/
	static const char *
	node_variant_text(enum pcmk__node_variant variant)
	{
	switch (variant) {
	case pcmk__node_variant_cluster:
	return PCMK_VALUE_MEMBER;
	case pcmk__node_variant_remote:
	return PCMK_VALUE_REMOTE;
	case pcmk__node_variant_ping:
	return PCMK__VALUE_PING;
	default:
	return PCMK_VALUE_UNKNOWN;
	}
	}

	PCMK__OUTPUT_ARGS("node", "pcmk_node_t ", "uint32_t", "bool", "GList ",
	"GList *")
	static int
	node_xml(pcmk__output_t *out, va_list args) {
	pcmk_node_t node = va_arg(args, pcmk_node_t );
	uint32_t show_opts G_GNUC_UNUSED = va_arg(args, uint32_t);
	bool full = va_arg(args, int);
	GList only_node = va_arg(args, GList );
	GList only_rsc = va_arg(args, GList );

	if (full) {
	const char *online = pcmk__btoa(node->details->online);
	const char *standby = pcmk__flag_text(node->private->flags,
	pcmk__node_standby);
	const char *standby_onfail = pcmk__flag_text(node->private->flags,
	pcmk__node_fail_standby);
	const char *maintenance = pcmk__btoa(node->details->maintenance);
	const char *pending = pcmk__btoa(node->details->pending);
	const char *unclean = pcmk__btoa(node->details->unclean);
	const char *health = health_text(pe__node_health(node));
	const char *feature_set = get_node_feature_set(node);
	const char *shutdown = pcmk__btoa(node->details->shutdown);
	const char *expected_up = pcmk__flag_text(node->private->flags,
	pcmk__node_expected_up);
	const bool is_dc = pcmk__same_node(node,
	node->private->scheduler->dc_node);
	int length = g_list_length(node->details->running_rsc);
	char *resources_running = pcmk__itoa(length);
	const char *node_type = node_variant_text(node->private->variant);

	int rc = pcmk_rc_ok;

	rc = pe__name_and_nvpairs_xml(out, true, PCMK_XE_NODE,
	PCMK_XA_NAME, node->private->name,
	PCMK_XA_ID, node->private->id,
	PCMK_XA_ONLINE, online,
	PCMK_XA_STANDBY, standby,
	PCMK_XA_STANDBY_ONFAIL, standby_onfail,
	PCMK_XA_MAINTENANCE, maintenance,
	PCMK_XA_PENDING, pending,
	PCMK_XA_UNCLEAN, unclean,
	PCMK_XA_HEALTH, health,
	PCMK_XA_FEATURE_SET, feature_set,
	PCMK_XA_SHUTDOWN, shutdown,
	PCMK_XA_EXPECTED_UP, expected_up,
	PCMK_XA_IS_DC, pcmk__btoa(is_dc),
	PCMK_XA_RESOURCES_RUNNING, resources_running,
	PCMK_XA_TYPE, node_type,
	NULL);

	free(resources_running);
	CRM_ASSERT(rc == pcmk_rc_ok);

	if (pcmk__is_guest_or_bundle_node(node)) {
	xmlNodePtr xml_node = pcmk__output_xml_peek_parent(out);
	crm_xml_add(xml_node, PCMK_XA_ID_AS_RESOURCE,
	node->private->remote->private->launcher->id);
	}

	if (pcmk_is_set(show_opts, pcmk_show_rscs_by_node)) {
	GList *lpc = NULL;

	for (lpc = node->details->running_rsc; lpc != NULL; lpc = lpc->next) {
	pcmk_resource_t rsc = (pcmk_resource_t ) lpc->data;

	show_opts \|= pcmk_show_rsc_only;
	out->message(out, pcmk__map_element_name(rsc->private->xml),
	show_opts, rsc, only_node, only_rsc);
	}
	}

	out->end_list(out);
	} else {
	pcmk__output_xml_create_parent(out, PCMK_XE_NODE,
	PCMK_XA_NAME, node->private->name,
	NULL);
	}

	return pcmk_rc_ok;
	}

	PCMK__OUTPUT_ARGS("node-attribute", "const char ", "const char ", "bool", "int")
	static int
	node_attribute_text(pcmk__output_t *out, va_list args) {
	const char name = va_arg(args, const char );
	const char value = va_arg(args, const char );
	bool add_extra = va_arg(args, int);
	int expected_score = va_arg(args, int);

	if (add_extra) {
	int v;

	if (value == NULL) {
	v = 0;
	} else {
	pcmk__scan_min_int(value, &v, INT_MIN);
	}
	if (v <= 0) {
	out->list_item(out, NULL, "%-32s\t: %-10s\t: Connectivity is lost", name, value);
	} else if (v < expected_score) {
	out->list_item(out, NULL, "%-32s\t: %-10s\t: Connectivity is degraded (Expected=%d)", name, value, expected_score);
	} else {
	out->list_item(out, NULL, "%-32s\t: %-10s", name, value);
	}
	} else {
	out->list_item(out, NULL, "%-32s\t: %-10s", name, value);
	}

	return pcmk_rc_ok;
	}

	PCMK__OUTPUT_ARGS("node-attribute", "const char ", "const char ", "bool", "int")
	static int
	node_attribute_html(pcmk__output_t *out, va_list args) {
	const char name = va_arg(args, const char );
	const char value = va_arg(args, const char );
	bool add_extra = va_arg(args, int);
	int expected_score = va_arg(args, int);

	if (add_extra) {
	int v = 0;
	xmlNodePtr item_node = pcmk__output_create_xml_node(out, "li", NULL);
	xmlNode *child = NULL;

	if (value != NULL) {
	pcmk__scan_min_int(value, &v, INT_MIN);
	}

	child = pcmk__html_create(item_node, PCMK__XE_SPAN, NULL, NULL);
	pcmk__xe_set_content(child, "%s: %s", name, value);

	if (v <= 0) {
	child = pcmk__html_create(item_node, PCMK__XE_SPAN, NULL,
	PCMK__VALUE_BOLD);
	pcmk__xe_set_content(child, "(connectivity is lost)");

	} else if (v < expected_score) {
	child = pcmk__html_create(item_node, PCMK__XE_SPAN, NULL,
	PCMK__VALUE_BOLD);
	pcmk__xe_set_content(child,
	"(connectivity is degraded -- expected %d)",
	expected_score);
	}
	} else {
	out->list_item(out, NULL, "%s: %s", name, value);
	}

	return pcmk_rc_ok;
	}

	PCMK__OUTPUT_ARGS("node-and-op", "pcmk_scheduler_t ", "xmlNode ")
	static int
	node_and_op(pcmk__output_t *out, va_list args) {
	pcmk_scheduler_t scheduler = va_arg(args, pcmk_scheduler_t );
	xmlNodePtr xml_op = va_arg(args, xmlNodePtr);

	pcmk_resource_t *rsc = NULL;
	gchar *node_str = NULL;
	char *last_change_str = NULL;

	const char *op_rsc = crm_element_value(xml_op, PCMK_XA_RESOURCE);
	int status;
	time_t last_change = 0;

	pcmk__scan_min_int(crm_element_value(xml_op, PCMK__XA_OP_STATUS), &status,
	PCMK_EXEC_UNKNOWN);

	rsc = pe_find_resource(scheduler->resources, op_rsc);

	if (rsc) {
	const pcmk_node_t *node = pcmk__current_node(rsc);
	const char *target_role = g_hash_table_lookup(rsc->private->meta,
	PCMK_META_TARGET_ROLE);
	uint32_t show_opts = pcmk_show_rsc_only \| pcmk_show_pending;

	if (node == NULL) {
	node = rsc->private->pending_node;
	}

	node_str = pcmk__native_output_string(rsc, rsc_printable_id(rsc), node,
	show_opts, target_role, false);
	} else {
	node_str = crm_strdup_printf("Unknown resource %s", op_rsc);
	}

	if (crm_element_value_epoch(xml_op, PCMK_XA_LAST_RC_CHANGE,
	&last_change) == pcmk_ok) {
	const char *exec_time = crm_element_value(xml_op, PCMK_XA_EXEC_TIME);

	last_change_str = crm_strdup_printf(", %s='%s', exec=%sms",
	PCMK_XA_LAST_RC_CHANGE,
	pcmk__trim(ctime(&last_change)),
	exec_time);
	}

	out->list_item(out, NULL, "%s: %s (node=%s, call=%s, rc=%s%s): %s",
	node_str, pcmk__xe_history_key(xml_op),
	crm_element_value(xml_op, PCMK_XA_UNAME),
	crm_element_value(xml_op, PCMK__XA_CALL_ID),
	crm_element_value(xml_op, PCMK__XA_RC_CODE),
	last_change_str ? last_change_str : "",
	pcmk_exec_status_str(status));

	g_free(node_str);
	free(last_change_str);
	return pcmk_rc_ok;
	}

	PCMK__OUTPUT_ARGS("node-and-op", "pcmk_scheduler_t ", "xmlNode ")
	static int
	node_and_op_xml(pcmk__output_t *out, va_list args) {
	pcmk_scheduler_t scheduler = va_arg(args, pcmk_scheduler_t );
	xmlNodePtr xml_op = va_arg(args, xmlNodePtr);

	pcmk_resource_t *rsc = NULL;
	const char *uname = crm_element_value(xml_op, PCMK_XA_UNAME);
	const char *call_id = crm_element_value(xml_op, PCMK__XA_CALL_ID);
	const char *rc_s = crm_element_value(xml_op, PCMK__XA_RC_CODE);
	const char *status_s = NULL;
	const char *op_rsc = crm_element_value(xml_op, PCMK_XA_RESOURCE);
	int status;
	time_t last_change = 0;
	xmlNode *node = NULL;

	pcmk__scan_min_int(crm_element_value(xml_op, PCMK__XA_OP_STATUS),
	&status, PCMK_EXEC_UNKNOWN);
	status_s = pcmk_exec_status_str(status);

	node = pcmk__output_create_xml_node(out, PCMK_XE_OPERATION,
	PCMK_XA_OP, pcmk__xe_history_key(xml_op),
	PCMK_XA_NODE, uname,
	PCMK_XA_CALL, call_id,
	PCMK_XA_RC, rc_s,
	PCMK_XA_STATUS, status_s,
	NULL);

	rsc = pe_find_resource(scheduler->resources, op_rsc);

	if (rsc) {
	const char *class = crm_element_value(rsc->private->xml, PCMK_XA_CLASS);
	const char *provider = crm_element_value(rsc->private->xml,
	PCMK_XA_PROVIDER);
	const char *kind = crm_element_value(rsc->private->xml, PCMK_XA_TYPE);
	bool has_provider = pcmk_is_set(pcmk_get_ra_caps(class),
	pcmk_ra_cap_provider);

	char *agent_tuple = crm_strdup_printf("%s:%s:%s",
	class,
	(has_provider? provider : ""),
	kind);

	pcmk__xe_set_props(node,
	PCMK_XA_RSC, rsc_printable_id(rsc),
	PCMK_XA_AGENT, agent_tuple,
	NULL);
	free(agent_tuple);
	}

	if (crm_element_value_epoch(xml_op, PCMK_XA_LAST_RC_CHANGE,
	&last_change) == pcmk_ok) {
	const char *last_rc_change = pcmk__trim(ctime(&last_change));
	const char *exec_time = crm_element_value(xml_op, PCMK_XA_EXEC_TIME);

	pcmk__xe_set_props(node,
	PCMK_XA_LAST_RC_CHANGE, last_rc_change,
	PCMK_XA_EXEC_TIME, exec_time,
	NULL);
	}

	return pcmk_rc_ok;
	}

	PCMK__OUTPUT_ARGS("node-attribute", "const char ", "const char ", "bool", "int")
	static int
	node_attribute_xml(pcmk__output_t *out, va_list args) {
	const char name = va_arg(args, const char );
	const char value = va_arg(args, const char );
	bool add_extra = va_arg(args, int);
	int expected_score = va_arg(args, int);

	xmlNodePtr node = pcmk__output_create_xml_node(out, PCMK_XE_ATTRIBUTE,
	PCMK_XA_NAME, name,
	PCMK_XA_VALUE, value,
	NULL);

	if (add_extra) {
	char *buf = pcmk__itoa(expected_score);
	crm_xml_add(node, PCMK_XA_EXPECTED, buf);
	free(buf);
	}

	return pcmk_rc_ok;
	}

	PCMK__OUTPUT_ARGS("node-attribute-list", "pcmk_scheduler_t *", "uint32_t",
	"bool", "GList ", "GList ")
	static int
	node_attribute_list(pcmk__output_t *out, va_list args) {
	pcmk_scheduler_t scheduler = va_arg(args, pcmk_scheduler_t );
	uint32_t show_opts = va_arg(args, uint32_t);
	bool print_spacer = va_arg(args, int);
	GList only_node = va_arg(args, GList );
	GList only_rsc = va_arg(args, GList );

	int rc = pcmk_rc_no_output;

	/* Display each node's attributes */
	for (GList *gIter = scheduler->nodes; gIter != NULL; gIter = gIter->next) {
	pcmk_node_t *node = gIter->data;

	GList *attr_list = NULL;
	GHashTableIter iter;
	gpointer key;

	if (!node \|\| !node->details \|\| !node->details->online) {
	continue;
	}

	g_hash_table_iter_init(&iter, node->private->attrs);
	while (g_hash_table_iter_next (&iter, &key, NULL)) {
	attr_list = filter_attr_list(attr_list, key);
	}

	if (attr_list == NULL) {
	continue;
	}

	if (!pcmk__str_in_list(node->private->name, only_node,
	pcmk__str_star_matches\|pcmk__str_casei)) {
	g_list_free(attr_list);
	continue;
	}

	PCMK__OUTPUT_LIST_HEADER(out, print_spacer, rc, "Node Attributes");

	out->message(out, "node", node, show_opts, false, only_node, only_rsc);

	for (GList *aIter = attr_list; aIter != NULL; aIter = aIter->next) {
	const char *name = aIter->data;
	const char *value = NULL;
	int expected_score = 0;
	bool add_extra = false;

	value = pcmk__node_attr(node, name, NULL, pcmk__rsc_node_current);

	add_extra = add_extra_info(node, node->details->running_rsc,
	scheduler, name, &expected_score);

	/* Print attribute name and value */
	out->message(out, "node-attribute", name, value, add_extra,
	expected_score);
	}

	g_list_free(attr_list);
	out->end_list(out);
	}

	PCMK__OUTPUT_LIST_FOOTER(out, rc);
	return rc;
	}

	PCMK__OUTPUT_ARGS("node-capacity", "const pcmk_node_t ", "const char ")
	static int
	node_capacity(pcmk__output_t *out, va_list args)
	{
	const pcmk_node_t node = va_arg(args, pcmk_node_t );
	const char comment = va_arg(args, const char );

	char *dump_text = crm_strdup_printf("%s: %s capacity:",
	comment, pcmk__node_name(node));

	g_hash_table_foreach(node->private->utilization, append_dump_text,
	&dump_text);
	out->list_item(out, NULL, "%s", dump_text);
	free(dump_text);

	return pcmk_rc_ok;
	}

	PCMK__OUTPUT_ARGS("node-capacity", "const pcmk_node_t ", "const char ")
	static int
	node_capacity_xml(pcmk__output_t *out, va_list args)
	{
	const pcmk_node_t node = va_arg(args, pcmk_node_t );
	const char *uname = node->private->name;
	const char comment = va_arg(args, const char );

	xmlNodePtr xml_node = pcmk__output_create_xml_node(out, PCMK_XE_CAPACITY,
	PCMK_XA_NODE, uname,
	PCMK_XA_COMMENT, comment,
	NULL);
	g_hash_table_foreach(node->private->utilization, add_dump_node, xml_node);

	return pcmk_rc_ok;
	}

	PCMK__OUTPUT_ARGS("node-history-list", "pcmk_scheduler_t ", "pcmk_node_t ",
	"xmlNode ", "GList ", "GList *", "uint32_t", "uint32_t")
	static int
	node_history_list(pcmk__output_t *out, va_list args) {
	pcmk_scheduler_t scheduler = va_arg(args, pcmk_scheduler_t );
	pcmk_node_t node = va_arg(args, pcmk_node_t );
	xmlNode node_state = va_arg(args, xmlNode );
	GList only_node = va_arg(args, GList );
	GList only_rsc = va_arg(args, GList );
	uint32_t section_opts = va_arg(args, uint32_t);
	uint32_t show_opts = va_arg(args, uint32_t);

	xmlNode *lrm_rsc = NULL;
	xmlNode *rsc_entry = NULL;
	int rc = pcmk_rc_no_output;

	lrm_rsc = pcmk__xe_first_child(node_state, PCMK__XE_LRM, NULL, NULL);
	lrm_rsc = pcmk__xe_first_child(lrm_rsc, PCMK__XE_LRM_RESOURCES, NULL, NULL);

	/* Print history of each of the node's resources */
	for (rsc_entry = pcmk__xe_first_child(lrm_rsc, PCMK__XE_LRM_RESOURCE, NULL,
	NULL);
	rsc_entry != NULL; rsc_entry = pcmk__xe_next_same(rsc_entry)) {

	const char *rsc_id = crm_element_value(rsc_entry, PCMK_XA_ID);
	pcmk_resource_t *rsc = pe_find_resource(scheduler->resources, rsc_id);
	const pcmk_resource_t *parent = pe__const_top_resource(rsc, false);

	/* We can't use is_filtered here to filter group resources. For is_filtered,
	* we have to decide whether to check the parent or not. If we check the
	* parent, all elements of a group will always be printed because that's how
	* is_filtered works for groups. If we do not check the parent, sometimes
	* this will filter everything out.
	*
	* For other resource types, is_filtered is okay.
	*/
	if (pcmk__is_group(parent)) {
	if (!pcmk__str_in_list(rsc_printable_id(rsc), only_rsc,
	pcmk__str_star_matches)
	&& !pcmk__str_in_list(rsc_printable_id(parent), only_rsc,
	pcmk__str_star_matches)) {
	continue;
	}
	} else if (rsc->private->fns->is_filtered(rsc, only_rsc, TRUE)) {
	continue;
	}

	if (!pcmk_is_set(section_opts, pcmk_section_operations)) {
	time_t last_failure = 0;
	int failcount = pe_get_failcount(node, rsc, &last_failure,
	pcmk__fc_default, NULL);

	if (failcount <= 0) {
	continue;
	}

	if (rc == pcmk_rc_no_output) {
	rc = pcmk_rc_ok;
	out->message(out, "node", node, show_opts, false, only_node,
	only_rsc);
	}

	out->message(out, "resource-history", rsc, rsc_id, false,
	failcount, last_failure, false);
	} else {
	GList *op_list = get_operation_list(rsc_entry);
	pcmk_resource_t *rsc = NULL;

	if (op_list == NULL) {
	continue;
	}

	rsc = pe_find_resource(scheduler->resources,
	crm_element_value(rsc_entry, PCMK_XA_ID));

	if (rc == pcmk_rc_no_output) {
	rc = pcmk_rc_ok;
	out->message(out, "node", node, show_opts, false, only_node,
	only_rsc);
	}

	out->message(out, "resource-operation-list", scheduler, rsc, node,
	op_list, show_opts);
	}
	}

	PCMK__OUTPUT_LIST_FOOTER(out, rc);
	return rc;
	}

	PCMK__OUTPUT_ARGS("node-list", "GList ", "GList ", "GList *", "uint32_t", "bool")
	static int
	node_list_html(pcmk__output_t *out, va_list args) {
	GList nodes = va_arg(args, GList );
	GList only_node = va_arg(args, GList );
	GList only_rsc = va_arg(args, GList );
	uint32_t show_opts = va_arg(args, uint32_t);
	bool print_spacer G_GNUC_UNUSED = va_arg(args, int);

	int rc = pcmk_rc_no_output;

	for (GList *gIter = nodes; gIter != NULL; gIter = gIter->next) {
	pcmk_node_t node = (pcmk_node_t ) gIter->data;

	if (!pcmk__str_in_list(node->private->name, only_node,
	pcmk__str_star_matches\|pcmk__str_casei)) {
	continue;
	}

	PCMK__OUTPUT_LIST_HEADER(out, false, rc, "Node List");

	out->message(out, "node", node, show_opts, true, only_node, only_rsc);
	}

	PCMK__OUTPUT_LIST_FOOTER(out, rc);
	return rc;
	}

	PCMK__OUTPUT_ARGS("node-list", "GList ", "GList ", "GList *", "uint32_t", "bool")
	static int
	node_list_text(pcmk__output_t *out, va_list args) {
	GList nodes = va_arg(args, GList );
	GList only_node = va_arg(args, GList );
	GList only_rsc = va_arg(args, GList );
	uint32_t show_opts = va_arg(args, uint32_t);
	bool print_spacer = va_arg(args, int);

	/* space-separated lists of node names */
	GString *online_nodes = NULL;
	GString *online_remote_nodes = NULL;
	GString *online_guest_nodes = NULL;
	GString *offline_nodes = NULL;
	GString *offline_remote_nodes = NULL;

	int rc = pcmk_rc_no_output;

	for (GList *gIter = nodes; gIter != NULL; gIter = gIter->next) {
	pcmk_node_t node = (pcmk_node_t ) gIter->data;
	char *node_name = pe__node_display_name(node, pcmk_is_set(show_opts, pcmk_show_node_id));

	if (!pcmk__str_in_list(node->private->name, only_node,
	pcmk__str_star_matches\|pcmk__str_casei)) {
	free(node_name);
	continue;
	}

	PCMK__OUTPUT_LIST_HEADER(out, print_spacer, rc, "Node List");

	// Determine whether to display node individually or in a list
	if (node->details->unclean \|\| node->details->pending
	\|\| (pcmk_is_set(node->private->flags, pcmk__node_fail_standby)
	&& node->details->online)
	\|\| pcmk_is_set(node->private->flags, pcmk__node_standby)
	\|\| node->details->maintenance
	\|\| pcmk_is_set(show_opts, pcmk_show_rscs_by_node)
	\|\| pcmk_is_set(show_opts, pcmk_show_feature_set)
	\|\| (pe__node_health(node) <= 0)) {
	// Display node individually

	} else if (node->details->online) {
	// Display online node in a list
	if (pcmk__is_guest_or_bundle_node(node)) {
	pcmk__add_word(&online_guest_nodes, 1024, node_name);

	} else if (pcmk__is_remote_node(node)) {
	pcmk__add_word(&online_remote_nodes, 1024, node_name);

	} else {
	pcmk__add_word(&online_nodes, 1024, node_name);
	}
	free(node_name);
	continue;

	} else {
	// Display offline node in a list
	if (pcmk__is_remote_node(node)) {
	pcmk__add_word(&offline_remote_nodes, 1024, node_name);

	} else if (pcmk__is_guest_or_bundle_node(node)) {
	/* ignore offline guest nodes */

	} else {
	pcmk__add_word(&offline_nodes, 1024, node_name);
	}
	free(node_name);
	continue;
	}

	/* If we get here, node is in bad state, or we're grouping by node */
	out->message(out, "node", node, show_opts, true, only_node, only_rsc);
	free(node_name);
	}

	/* If we're not grouping by node, summarize nodes by status */
	if (online_nodes != NULL) {
	out->list_item(out, "Online", "[ %s ]",
	(const char *) online_nodes->str);
	g_string_free(online_nodes, TRUE);
	}
	if (offline_nodes != NULL) {
	out->list_item(out, "OFFLINE", "[ %s ]",
	(const char *) offline_nodes->str);
	g_string_free(offline_nodes, TRUE);
	}
	if (online_remote_nodes) {
	out->list_item(out, "RemoteOnline", "[ %s ]",
	(const char *) online_remote_nodes->str);
	g_string_free(online_remote_nodes, TRUE);
	}
	if (offline_remote_nodes) {
	out->list_item(out, "RemoteOFFLINE", "[ %s ]",
	(const char *) offline_remote_nodes->str);
	g_string_free(offline_remote_nodes, TRUE);
	}
	if (online_guest_nodes != NULL) {
	out->list_item(out, "GuestOnline", "[ %s ]",
	(const char *) online_guest_nodes->str);
	g_string_free(online_guest_nodes, TRUE);
	}

	PCMK__OUTPUT_LIST_FOOTER(out, rc);
	return rc;
	}

	PCMK__OUTPUT_ARGS("node-list", "GList ", "GList ", "GList *", "uint32_t", "bool")
	static int
	node_list_xml(pcmk__output_t *out, va_list args) {
	GList nodes = va_arg(args, GList );
	GList only_node = va_arg(args, GList );
	GList only_rsc = va_arg(args, GList );
	uint32_t show_opts = va_arg(args, uint32_t);
	bool print_spacer G_GNUC_UNUSED = va_arg(args, int);

	/* PCMK_XE_NODES acts as the list's element name for CLI tools that use
	* pcmk__output_enable_list_element. Otherwise PCMK_XE_NODES is the
	* value of the list's PCMK_XA_NAME attribute.
	*/
	out->begin_list(out, NULL, NULL, PCMK_XE_NODES);
	for (GList *gIter = nodes; gIter != NULL; gIter = gIter->next) {
	pcmk_node_t node = (pcmk_node_t ) gIter->data;

	if (!pcmk__str_in_list(node->private->name, only_node,
	pcmk__str_star_matches\|pcmk__str_casei)) {
	continue;
	}

	out->message(out, "node", node, show_opts, true, only_node, only_rsc);
	}
	out->end_list(out);

	return pcmk_rc_ok;
	}

	PCMK__OUTPUT_ARGS("node-summary", "pcmk_scheduler_t ", "GList ", "GList *",
	"uint32_t", "uint32_t", "bool")
	static int
	node_summary(pcmk__output_t *out, va_list args) {
	pcmk_scheduler_t scheduler = va_arg(args, pcmk_scheduler_t );
	GList only_node = va_arg(args, GList );
	GList only_rsc = va_arg(args, GList );
	uint32_t section_opts = va_arg(args, uint32_t);
	uint32_t show_opts = va_arg(args, uint32_t);
	bool print_spacer = va_arg(args, int);

	xmlNode *node_state = NULL;
	xmlNode *cib_status = pcmk_find_cib_element(scheduler->input,
	PCMK_XE_STATUS);
	int rc = pcmk_rc_no_output;

	if (xmlChildElementCount(cib_status) == 0) {
	return rc;
	}

	for (node_state = pcmk__xe_first_child(cib_status, PCMK__XE_NODE_STATE,
	NULL, NULL);
	node_state != NULL; node_state = pcmk__xe_next_same(node_state)) {

	pcmk_node_t *node = pe_find_node_id(scheduler->nodes,
	pcmk__xe_id(node_state));

	if (!node \|\| !node->details \|\| !node->details->online) {
	continue;
	}

	if (!pcmk__str_in_list(node->private->name, only_node,
	pcmk__str_star_matches\|pcmk__str_casei)) {
	continue;
	}

	PCMK__OUTPUT_LIST_HEADER(out, print_spacer, rc,
	pcmk_is_set(section_opts, pcmk_section_operations) ? "Operations" : "Migration Summary");

	out->message(out, "node-history-list", scheduler, node, node_state,
	only_node, only_rsc, section_opts, show_opts);
	}

	PCMK__OUTPUT_LIST_FOOTER(out, rc);
	return rc;
	}

	PCMK__OUTPUT_ARGS("node-weight", "const pcmk_resource_t ", "const char ",
	"const char ", "const char ")
	static int
	node_weight(pcmk__output_t *out, va_list args)
	{
	const pcmk_resource_t rsc = va_arg(args, const pcmk_resource_t );
	const char prefix = va_arg(args, const char );
	const char uname = va_arg(args, const char );
	const char score = va_arg(args, const char );

	if (rsc) {
	out->list_item(out, NULL, "%s: %s allocation score on %s: %s",
	prefix, rsc->id, uname, score);
	} else {
	out->list_item(out, NULL, "%s: %s = %s", prefix, uname, score);
	}

	return pcmk_rc_ok;
	}

	PCMK__OUTPUT_ARGS("node-weight", "const pcmk_resource_t ", "const char ",
	"const char ", "const char ")
	static int
	node_weight_xml(pcmk__output_t *out, va_list args)
	{
	const pcmk_resource_t rsc = va_arg(args, const pcmk_resource_t );
	const char prefix = va_arg(args, const char );
	const char uname = va_arg(args, const char );
	const char score = va_arg(args, const char );

	xmlNodePtr node = pcmk__output_create_xml_node(out, PCMK_XE_NODE_WEIGHT,
	PCMK_XA_FUNCTION, prefix,
	PCMK_XA_NODE, uname,
	PCMK_XA_SCORE, score,
	NULL);

	if (rsc) {
	crm_xml_add(node, PCMK_XA_ID, rsc->id);
	}

	return pcmk_rc_ok;
	}

	PCMK__OUTPUT_ARGS("op-history", "xmlNode ", "const char ", "const char *", "int", "uint32_t")
	static int
	op_history_text(pcmk__output_t *out, va_list args) {
	xmlNodePtr xml_op = va_arg(args, xmlNodePtr);
	const char task = va_arg(args, const char );
	const char interval_ms_s = va_arg(args, const char );
	int rc = va_arg(args, int);
	uint32_t show_opts = va_arg(args, uint32_t);

	char *buf = op_history_string(xml_op, task, interval_ms_s, rc,
	pcmk_is_set(show_opts, pcmk_show_timing));

	out->list_item(out, NULL, "%s", buf);

	free(buf);
	return pcmk_rc_ok;
	}

	PCMK__OUTPUT_ARGS("op-history", "xmlNode ", "const char ", "const char *", "int", "uint32_t")
	static int
	op_history_xml(pcmk__output_t *out, va_list args) {
	xmlNodePtr xml_op = va_arg(args, xmlNodePtr);
	const char task = va_arg(args, const char );
	const char interval_ms_s = va_arg(args, const char );
	int rc = va_arg(args, int);
	uint32_t show_opts = va_arg(args, uint32_t);

	const char *call_id = crm_element_value(xml_op, PCMK__XA_CALL_ID);
	char *rc_s = pcmk__itoa(rc);
	const char *rc_text = services_ocf_exitcode_str(rc);
	xmlNodePtr node = NULL;

	node = pcmk__output_create_xml_node(out, PCMK_XE_OPERATION_HISTORY,
	PCMK_XA_CALL, call_id,
	PCMK_XA_TASK, task,
	PCMK_XA_RC, rc_s,
	PCMK_XA_RC_TEXT, rc_text,
	NULL);
	free(rc_s);

	if (interval_ms_s && !pcmk__str_eq(interval_ms_s, "0", pcmk__str_casei)) {
	char *s = crm_strdup_printf("%sms", interval_ms_s);
	crm_xml_add(node, PCMK_XA_INTERVAL, s);
	free(s);
	}

	if (pcmk_is_set(show_opts, pcmk_show_timing)) {
	const char *value = NULL;
	time_t epoch = 0;

	if ((crm_element_value_epoch(xml_op, PCMK_XA_LAST_RC_CHANGE,
	&epoch) == pcmk_ok) && (epoch > 0)) {
	char *s = pcmk__epoch2str(&epoch, 0);
	crm_xml_add(node, PCMK_XA_LAST_RC_CHANGE, s);
	free(s);
	}

	value = crm_element_value(xml_op, PCMK_XA_EXEC_TIME);
	if (value) {
	char *s = crm_strdup_printf("%sms", value);
	crm_xml_add(node, PCMK_XA_EXEC_TIME, s);
	free(s);
	}
	value = crm_element_value(xml_op, PCMK_XA_QUEUE_TIME);
	if (value) {
	char *s = crm_strdup_printf("%sms", value);
	crm_xml_add(node, PCMK_XA_QUEUE_TIME, s);
	free(s);
	}
	}

	return pcmk_rc_ok;
	}

	PCMK__OUTPUT_ARGS("promotion-score", "pcmk_resource_t ", "pcmk_node_t ",
	"const char *")
	static int
	promotion_score(pcmk__output_t *out, va_list args)
	{
	pcmk_resource_t child_rsc = va_arg(args, pcmk_resource_t );
	pcmk_node_t chosen = va_arg(args, pcmk_node_t );
	const char score = va_arg(args, const char );

	if (chosen == NULL) {
	out->list_item(out, NULL, "%s promotion score (inactive): %s",
	child_rsc->id, score);
	} else {
	out->list_item(out, NULL, "%s promotion score on %s: %s",
	child_rsc->id, pcmk__node_name(chosen), score);
	}
	return pcmk_rc_ok;
	}

	PCMK__OUTPUT_ARGS("promotion-score", "pcmk_resource_t ", "pcmk_node_t ",
	"const char *")
	static int
	promotion_score_xml(pcmk__output_t *out, va_list args)
	{
	pcmk_resource_t child_rsc = va_arg(args, pcmk_resource_t );
	pcmk_node_t chosen = va_arg(args, pcmk_node_t );
	const char score = va_arg(args, const char );

	xmlNodePtr node = pcmk__output_create_xml_node(out, PCMK_XE_PROMOTION_SCORE,
	PCMK_XA_ID, child_rsc->id,
	PCMK_XA_SCORE, score,
	NULL);

	if (chosen) {
	crm_xml_add(node, PCMK_XA_NODE, chosen->private->name);
	}

	return pcmk_rc_ok;
	}

	PCMK__OUTPUT_ARGS("resource-config", "const pcmk_resource_t *", "bool")
	static int
	resource_config(pcmk__output_t *out, va_list args) {
	const pcmk_resource_t rsc = va_arg(args, const pcmk_resource_t );
	GString *xml_buf = g_string_sized_new(1024);
	bool raw = va_arg(args, int);

	formatted_xml_buf(rsc, xml_buf, raw);

	out->output_xml(out, PCMK_XE_XML, xml_buf->str);

	g_string_free(xml_buf, TRUE);
	return pcmk_rc_ok;
	}

	PCMK__OUTPUT_ARGS("resource-config", "const pcmk_resource_t *", "bool")
	static int
	resource_config_text(pcmk__output_t *out, va_list args) {
	pcmk__formatted_printf(out, "Resource XML:\n");
	return resource_config(out, args);
	}

	PCMK__OUTPUT_ARGS("resource-history", "pcmk_resource_t ", "const char ",
	"bool", "int", "time_t", "bool")
	static int
	resource_history_text(pcmk__output_t *out, va_list args) {
	pcmk_resource_t rsc = va_arg(args, pcmk_resource_t );
	const char rsc_id = va_arg(args, const char );
	bool all = va_arg(args, int);
	int failcount = va_arg(args, int);
	time_t last_failure = va_arg(args, time_t);
	bool as_header = va_arg(args, int);

	char *buf = resource_history_string(rsc, rsc_id, all, failcount, last_failure);

	if (as_header) {
	out->begin_list(out, NULL, NULL, "%s", buf);
	} else {
	out->list_item(out, NULL, "%s", buf);
	}

	free(buf);
	return pcmk_rc_ok;
	}

	PCMK__OUTPUT_ARGS("resource-history", "pcmk_resource_t ", "const char ",
	"bool", "int", "time_t", "bool")
	static int
	resource_history_xml(pcmk__output_t *out, va_list args) {
	pcmk_resource_t rsc = va_arg(args, pcmk_resource_t );
	const char rsc_id = va_arg(args, const char );
	bool all = va_arg(args, int);
	int failcount = va_arg(args, int);
	time_t last_failure = va_arg(args, time_t);
	bool as_header = va_arg(args, int);

	xmlNodePtr node = pcmk__output_xml_create_parent(out,
	PCMK_XE_RESOURCE_HISTORY,
	PCMK_XA_ID, rsc_id,
	NULL);

	if (rsc == NULL) {
	pcmk__xe_set_bool_attr(node, PCMK_XA_ORPHAN, true);
	} else if (all \|\| failcount \|\| last_failure > 0) {
	char *migration_s = pcmk__itoa(rsc->private->ban_after_failures);

	pcmk__xe_set_props(node,
	PCMK_XA_ORPHAN, PCMK_VALUE_FALSE,
	PCMK_META_MIGRATION_THRESHOLD, migration_s,
	NULL);
	free(migration_s);

	if (failcount > 0) {
	char *s = pcmk__itoa(failcount);

	crm_xml_add(node, PCMK_XA_FAIL_COUNT, s);
	free(s);
	}

	if (last_failure > 0) {
	char *s = pcmk__epoch2str(&last_failure, 0);

	crm_xml_add(node, PCMK_XA_LAST_FAILURE, s);
	free(s);
	}
	}

	if (!as_header) {
	pcmk__output_xml_pop_parent(out);
	}

	return pcmk_rc_ok;
	}

	static void
	print_resource_header(pcmk__output_t *out, uint32_t show_opts)
	{
	if (pcmk_is_set(show_opts, pcmk_show_rscs_by_node)) {
	/* Active resources have already been printed by node */
	out->begin_list(out, NULL, NULL, "Inactive Resources");
	} else if (pcmk_is_set(show_opts, pcmk_show_inactive_rscs)) {
	out->begin_list(out, NULL, NULL, "Full List of Resources");
	} else {
	out->begin_list(out, NULL, NULL, "Active Resources");
	}
	}


	PCMK__OUTPUT_ARGS("resource-list", "pcmk_scheduler_t *", "uint32_t", "bool",
	"GList ", "GList ", "bool")
	static int
	resource_list(pcmk__output_t *out, va_list args)
	{
	pcmk_scheduler_t scheduler = va_arg(args, pcmk_scheduler_t );
	uint32_t show_opts = va_arg(args, uint32_t);
	bool print_summary = va_arg(args, int);
	GList only_node = va_arg(args, GList );
	GList only_rsc = va_arg(args, GList );
	bool print_spacer = va_arg(args, int);

	GList *rsc_iter;
	int rc = pcmk_rc_no_output;
	bool printed_header = false;

	/* If we already showed active resources by node, and
	* we're not showing inactive resources, we have nothing to do
	*/
	if (pcmk_is_set(show_opts, pcmk_show_rscs_by_node) &&
	!pcmk_is_set(show_opts, pcmk_show_inactive_rscs)) {
	return rc;
	}

	/* If we haven't already printed resources grouped by node,
	* and brief output was requested, print resource summary */
	if (pcmk_is_set(show_opts, pcmk_show_brief)
	&& !pcmk_is_set(show_opts, pcmk_show_rscs_by_node)) {
	GList *rscs = pe__filter_rsc_list(scheduler->resources, only_rsc);

	PCMK__OUTPUT_SPACER_IF(out, print_spacer);
	print_resource_header(out, show_opts);
	printed_header = true;

	rc = pe__rscs_brief_output(out, rscs, show_opts);
	g_list_free(rscs);
	}

	/* For each resource, display it if appropriate */
	for (rsc_iter = scheduler->resources; rsc_iter != NULL; rsc_iter = rsc_iter->next) {
	pcmk_resource_t rsc = (pcmk_resource_t ) rsc_iter->data;
	int x;

	/* Complex resources may have some sub-resources active and some inactive */
	gboolean is_active = rsc->private->fns->active(rsc, TRUE);
	gboolean partially_active = rsc->private->fns->active(rsc, FALSE);

	/* Skip inactive orphans (deleted but still in CIB) */
	if (pcmk_is_set(rsc->flags, pcmk__rsc_removed) && !is_active) {
	continue;

	/* Skip active resources if we already displayed them by node */
	} else if (pcmk_is_set(show_opts, pcmk_show_rscs_by_node)) {
	if (is_active) {
	continue;
	}

	/* Skip primitives already counted in a brief summary */
	} else if (pcmk_is_set(show_opts, pcmk_show_brief)
	&& pcmk__is_primitive(rsc)) {
	continue;

	/* Skip resources that aren't at least partially active,
	* unless we're displaying inactive resources
	*/
	} else if (!partially_active && !pcmk_is_set(show_opts, pcmk_show_inactive_rscs)) {
	continue;

	} else if (partially_active && !pe__rsc_running_on_any(rsc, only_node)) {
	continue;
	}

	if (!printed_header) {
	PCMK__OUTPUT_SPACER_IF(out, print_spacer);
	print_resource_header(out, show_opts);
	printed_header = true;
	}

	/* Print this resource */
	x = out->message(out, pcmk__map_element_name(rsc->private->xml),
	show_opts, rsc, only_node, only_rsc);
	if (x == pcmk_rc_ok) {
	rc = pcmk_rc_ok;
	}
	}

	if (print_summary && rc != pcmk_rc_ok) {
	if (!printed_header) {
	PCMK__OUTPUT_SPACER_IF(out, print_spacer);
	print_resource_header(out, show_opts);
	printed_header = true;
	}

	if (pcmk_is_set(show_opts, pcmk_show_rscs_by_node)) {
	out->list_item(out, NULL, "No inactive resources");
	} else if (pcmk_is_set(show_opts, pcmk_show_inactive_rscs)) {
	out->list_item(out, NULL, "No resources");
	} else {
	out->list_item(out, NULL, "No active resources");
	}
	}

	if (printed_header) {
	out->end_list(out);
	}

	return rc;
	}

	PCMK__OUTPUT_ARGS("resource-operation-list", "pcmk_scheduler_t *",
	"pcmk_resource_t ", "pcmk_node_t ", "GList *", "uint32_t")
	static int
	resource_operation_list(pcmk__output_t *out, va_list args)
	{
	pcmk_scheduler_t *scheduler G_GNUC_UNUSED = va_arg(args,
	pcmk_scheduler_t *);
	pcmk_resource_t rsc = va_arg(args, pcmk_resource_t );
	pcmk_node_t node = va_arg(args, pcmk_node_t );
	GList op_list = va_arg(args, GList );
	uint32_t show_opts = va_arg(args, uint32_t);

	GList *gIter = NULL;
	int rc = pcmk_rc_no_output;

	/* Print each operation */
	for (gIter = op_list; gIter != NULL; gIter = gIter->next) {
	xmlNode xml_op = (xmlNode ) gIter->data;
	const char *task = crm_element_value(xml_op, PCMK_XA_OPERATION);
	const char *interval_ms_s = crm_element_value(xml_op,
	PCMK_META_INTERVAL);
	const char *op_rc = crm_element_value(xml_op, PCMK__XA_RC_CODE);
	int op_rc_i;

	pcmk__scan_min_int(op_rc, &op_rc_i, 0);

	/* Display 0-interval monitors as "probe" */
	if (pcmk__str_eq(task, PCMK_ACTION_MONITOR, pcmk__str_casei)
	&& pcmk__str_eq(interval_ms_s, "0", pcmk__str_null_matches \| pcmk__str_casei)) {
	task = "probe";
	}

	/* If this is the first printed operation, print heading for resource */
	if (rc == pcmk_rc_no_output) {
	time_t last_failure = 0;
	int failcount = pe_get_failcount(node, rsc, &last_failure,
	pcmk__fc_default, NULL);

	out->message(out, "resource-history", rsc, rsc_printable_id(rsc), true,
	failcount, last_failure, true);
	rc = pcmk_rc_ok;
	}

	/* Print the operation */
	out->message(out, "op-history", xml_op, task, interval_ms_s,
	op_rc_i, show_opts);
	}

	/* Free the list we created (no need to free the individual items) */
	g_list_free(op_list);

	PCMK__OUTPUT_LIST_FOOTER(out, rc);
	return rc;
	}

	PCMK__OUTPUT_ARGS("resource-util", "pcmk_resource_t ", "pcmk_node_t ",
	"const char *")
	static int
	resource_util(pcmk__output_t *out, va_list args)
	{
	pcmk_resource_t rsc = va_arg(args, pcmk_resource_t );
	pcmk_node_t node = va_arg(args, pcmk_node_t );
	const char fn = va_arg(args, const char );

	char *dump_text = crm_strdup_printf("%s: %s utilization on %s:",
	fn, rsc->id, pcmk__node_name(node));

	g_hash_table_foreach(rsc->private->utilization, append_dump_text,
	&dump_text);
	out->list_item(out, NULL, "%s", dump_text);
	free(dump_text);

	return pcmk_rc_ok;
	}

	PCMK__OUTPUT_ARGS("resource-util", "pcmk_resource_t ", "pcmk_node_t ",
	"const char *")
	static int
	resource_util_xml(pcmk__output_t *out, va_list args)
	{
	pcmk_resource_t rsc = va_arg(args, pcmk_resource_t );
	pcmk_node_t node = va_arg(args, pcmk_node_t );
	const char *uname = node->private->name;
	const char fn = va_arg(args, const char );

	xmlNodePtr xml_node = NULL;

	xml_node = pcmk__output_create_xml_node(out, PCMK_XE_UTILIZATION,
	PCMK_XA_RESOURCE, rsc->id,
	PCMK_XA_NODE, uname,
	PCMK_XA_FUNCTION, fn,
	NULL);
	g_hash_table_foreach(rsc->private->utilization, add_dump_node, xml_node);

	return pcmk_rc_ok;
	}

	+static inline const char *
	+ticket_status(pcmk__ticket_t *ticket)
	+{
	+ if (pcmk_is_set(ticket->flags, pcmk__ticket_granted)) {
	+ return PCMK_VALUE_GRANTED;
	+ }
	+ return PCMK_VALUE_REVOKED;
	+}
	+
	+static inline const char *
	+ticket_standby_text(pcmk__ticket_t *ticket)
	+{
	+ return pcmk_is_set(ticket->flags, pcmk__ticket_standby)? " [standby]" : "";
	+}
	+
	PCMK__OUTPUT_ARGS("ticket", "pcmk__ticket_t *", "bool", "bool")
	static int
	ticket_default(pcmk__output_t *out, va_list args) {
	pcmk__ticket_t ticket = va_arg(args, pcmk__ticket_t );
	bool raw = va_arg(args, int);
	bool details = va_arg(args, int);

	GString *detail_str = NULL;

	if (raw) {
	out->list_item(out, ticket->id, "%s", ticket->id);
	return pcmk_rc_ok;
	}

	if (details && g_hash_table_size(ticket->state) > 0) {
	GHashTableIter iter;
	const char *name = NULL;
	const char *value = NULL;
	bool already_added = false;

	detail_str = g_string_sized_new(100);
	pcmk__g_strcat(detail_str, "\t(", NULL);

	g_hash_table_iter_init(&iter, ticket->state);
	while (g_hash_table_iter_next(&iter, (void ) &name, (void ) &value)) {
	if (already_added) {
	g_string_append_printf(detail_str, ", %s=", name);
	} else {
	g_string_append_printf(detail_str, "%s=", name);
	already_added = true;
	}

	if (pcmk__str_any_of(name, PCMK_XA_LAST_GRANTED, "expires", NULL)) {
	char *epoch_str = NULL;
	long long time_ll;

	pcmk__scan_ll(value, &time_ll, 0);
	epoch_str = pcmk__epoch2str((const time_t *) &time_ll, 0);
	pcmk__g_strcat(detail_str, epoch_str, NULL);
	free(epoch_str);
	} else {
	pcmk__g_strcat(detail_str, value, NULL);
	}
	}

	pcmk__g_strcat(detail_str, ")", NULL);
	}

	if (ticket->last_granted > -1) {
	/* Prior to the introduction of the details & raw arguments to this
	* function, last-granted would always be added in this block. We need
	* to preserve that behavior. At the same time, we also need to preserve
	* the existing behavior from crm_ticket, which would include last-granted
	* as part of the (...) detail string.
	*
	* Luckily we can check detail_str - if it's NULL, either there were no
	* details, or we are preserving the previous behavior of this function.
	* If it's not NULL, we are either preserving the previous behavior of
	* crm_ticket or we were given details=true as an argument.
	*/
	if (detail_str == NULL) {
	char *epoch_str = pcmk__epoch2str(&(ticket->last_granted), 0);

	out->list_item(out, NULL, "%s\t%s%s last-granted=\"%s\"",
	- ticket->id,
	- (ticket->granted? "granted" : "revoked"),
	- (ticket->standby? " [standby]" : ""),
	- pcmk__s(epoch_str, ""));
	+ ticket->id, ticket_status(ticket),
	+ ticket_standby_text(ticket), pcmk__s(epoch_str, ""));
	free(epoch_str);
	} else {
	out->list_item(out, NULL, "%s\t%s%s %s",
	- ticket->id,
	- (ticket->granted? "granted" : "revoked"),
	- (ticket->standby? " [standby]" : ""),
	- detail_str->str);
	+ ticket->id, ticket_status(ticket),
	+ ticket_standby_text(ticket), detail_str->str);
	}
	} else {
	out->list_item(out, NULL, "%s\t%s%s%s", ticket->id,
	- ticket->granted ? "granted" : "revoked",
	- ticket->standby ? " [standby]" : "",
	+ ticket_status(ticket),
	+ ticket_standby_text(ticket),
	detail_str != NULL ? detail_str->str : "");
	}

	if (detail_str != NULL) {
	g_string_free(detail_str, TRUE);
	}

	return pcmk_rc_ok;
	}

	PCMK__OUTPUT_ARGS("ticket", "pcmk__ticket_t *", "bool", "bool")
	static int
	ticket_xml(pcmk__output_t *out, va_list args) {
	pcmk__ticket_t ticket = va_arg(args, pcmk__ticket_t );
	bool raw G_GNUC_UNUSED = va_arg(args, int);
	bool details G_GNUC_UNUSED = va_arg(args, int);

	- const char *status = NULL;
	- const char *standby = pcmk__btoa(ticket->standby);
	+ const char *standby = pcmk__flag_text(ticket->flags, pcmk__ticket_standby);

	xmlNodePtr node = NULL;
	GHashTableIter iter;
	const char *name = NULL;
	const char *value = NULL;

	- status = ticket->granted? PCMK_VALUE_GRANTED : PCMK_VALUE_REVOKED;
	-
	node = pcmk__output_create_xml_node(out, PCMK_XE_TICKET,
	PCMK_XA_ID, ticket->id,
	- PCMK_XA_STATUS, status,
	+ PCMK_XA_STATUS, ticket_status(ticket),
	PCMK_XA_STANDBY, standby,
	NULL);

	if (ticket->last_granted > -1) {
	char *buf = pcmk__epoch2str(&ticket->last_granted, 0);

	crm_xml_add(node, PCMK_XA_LAST_GRANTED, buf);
	free(buf);
	}

	g_hash_table_iter_init(&iter, ticket->state);
	while (g_hash_table_iter_next(&iter, (void ) &name, (void ) &value)) {
	/* PCMK_XA_LAST_GRANTED and "expires" are already added by the check
	* for ticket->last_granted above.
	*/
	if (pcmk__str_any_of(name, PCMK_XA_LAST_GRANTED, PCMK_XA_EXPIRES,
	NULL)) {
	continue;
	}

	crm_xml_add(node, name, value);
	}

	return pcmk_rc_ok;
	}

	PCMK__OUTPUT_ARGS("ticket-list", "GHashTable *", "bool", "bool", "bool")
	static int
	ticket_list(pcmk__output_t *out, va_list args) {
	GHashTable tickets = va_arg(args, GHashTable );
	bool print_spacer = va_arg(args, int);
	bool raw = va_arg(args, int);
	bool details = va_arg(args, int);

	GHashTableIter iter;
	gpointer value;

	if (g_hash_table_size(tickets) == 0) {
	return pcmk_rc_no_output;
	}

	PCMK__OUTPUT_SPACER_IF(out, print_spacer);

	/* Print section heading */
	out->begin_list(out, NULL, NULL, "Tickets");

	/* Print each ticket */
	g_hash_table_iter_init(&iter, tickets);
	while (g_hash_table_iter_next(&iter, NULL, &value)) {
	pcmk__ticket_t ticket = (pcmk__ticket_t ) value;
	out->message(out, "ticket", ticket, raw, details);
	}

	/* Close section */
	out->end_list(out);
	return pcmk_rc_ok;
	}

	static pcmk__message_entry_t fmt_functions[] = {
	{ "ban", "default", ban_text },
	{ "ban", "html", ban_html },
	{ "ban", "xml", ban_xml },
	{ "ban-list", "default", ban_list },
	{ "bundle", "default", pe__bundle_text },
	{ "bundle", "xml", pe__bundle_xml },
	{ "bundle", "html", pe__bundle_html },
	{ "clone", "default", pe__clone_default },
	{ "clone", "xml", pe__clone_xml },
	{ "cluster-counts", "default", cluster_counts_text },
	{ "cluster-counts", "html", cluster_counts_html },
	{ "cluster-counts", "xml", cluster_counts_xml },
	{ "cluster-dc", "default", cluster_dc_text },
	{ "cluster-dc", "html", cluster_dc_html },
	{ "cluster-dc", "xml", cluster_dc_xml },
	{ "cluster-options", "default", cluster_options_text },
	{ "cluster-options", "html", cluster_options_html },
	{ "cluster-options", "log", cluster_options_log },
	{ "cluster-options", "xml", cluster_options_xml },
	{ "cluster-summary", "default", cluster_summary },
	{ "cluster-summary", "html", cluster_summary_html },
	{ "cluster-stack", "default", cluster_stack_text },
	{ "cluster-stack", "html", cluster_stack_html },
	{ "cluster-stack", "xml", cluster_stack_xml },
	{ "cluster-times", "default", cluster_times_text },
	{ "cluster-times", "html", cluster_times_html },
	{ "cluster-times", "xml", cluster_times_xml },
	{ "failed-action", "default", failed_action_default },
	{ "failed-action", "xml", failed_action_xml },
	{ "failed-action-list", "default", failed_action_list },
	{ "group", "default", pe__group_default},
	{ "group", "xml", pe__group_xml },
	{ "maint-mode", "text", cluster_maint_mode_text },
	{ "node", "default", node_text },
	{ "node", "html", node_html },
	{ "node", "xml", node_xml },
	{ "node-and-op", "default", node_and_op },
	{ "node-and-op", "xml", node_and_op_xml },
	{ "node-capacity", "default", node_capacity },
	{ "node-capacity", "xml", node_capacity_xml },
	{ "node-history-list", "default", node_history_list },
	{ "node-list", "default", node_list_text },
	{ "node-list", "html", node_list_html },
	{ "node-list", "xml", node_list_xml },
	{ "node-weight", "default", node_weight },
	{ "node-weight", "xml", node_weight_xml },
	{ "node-attribute", "default", node_attribute_text },
	{ "node-attribute", "html", node_attribute_html },
	{ "node-attribute", "xml", node_attribute_xml },
	{ "node-attribute-list", "default", node_attribute_list },
	{ "node-summary", "default", node_summary },
	{ "op-history", "default", op_history_text },
	{ "op-history", "xml", op_history_xml },
	{ "primitive", "default", pe__resource_text },
	{ "primitive", "xml", pe__resource_xml },
	{ "primitive", "html", pe__resource_html },
	{ "promotion-score", "default", promotion_score },
	{ "promotion-score", "xml", promotion_score_xml },
	{ "resource-config", "default", resource_config },
	{ "resource-config", "text", resource_config_text },
	{ "resource-history", "default", resource_history_text },
	{ "resource-history", "xml", resource_history_xml },
	{ "resource-list", "default", resource_list },
	{ "resource-operation-list", "default", resource_operation_list },
	{ "resource-util", "default", resource_util },
	{ "resource-util", "xml", resource_util_xml },
	{ "ticket", "default", ticket_default },
	{ "ticket", "xml", ticket_xml },
	{ "ticket-list", "default", ticket_list },

	{ NULL, NULL, NULL }
	};

	void
	pe__register_messages(pcmk__output_t *out) {
	pcmk__register_messages(out, fmt_functions);
	}
	diff --git a/lib/pengine/unpack.c b/lib/pengine/unpack.c
	index 0b596aae04..254c905328 100644
	--- a/lib/pengine/unpack.c
	+++ b/lib/pengine/unpack.c
	@@ -1,5080 +1,5080 @@
	/*
	* Copyright 2004-2024 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.
	*/

	#include <crm_internal.h>

	#include <stdio.h>
	#include <string.h>
	#include <glib.h>
	#include <time.h>

	#include <crm/crm.h>
	#include <crm/services.h>
	#include <crm/common/xml.h>
	#include <crm/common/xml_internal.h>

	#include <crm/common/util.h>
	#include <crm/pengine/rules.h>
	#include <crm/pengine/internal.h>
	#include <pe_status_private.h>

	CRM_TRACE_INIT_DATA(pe_status);

	// A (parsed) resource action history entry
	struct action_history {
	pcmk_resource_t *rsc; // Resource that history is for
	pcmk_node_t *node; // Node that history is for
	xmlNode *xml; // History entry XML

	// Parsed from entry XML
	const char *id; // XML ID of history entry
	const char *key; // Operation key of action
	const char *task; // Action name
	const char *exit_reason; // Exit reason given for result
	guint interval_ms; // Action interval
	int call_id; // Call ID of action
	int expected_exit_status; // Expected exit status of action
	int exit_status; // Actual exit status of action
	int execution_status; // Execution status of action
	};

	/* This uses pcmk__set_flags_as()/pcmk__clear_flags_as() directly rather than
	* use pcmk__set_scheduler_flags()/pcmk__clear_scheduler_flags() so that the
	* flag is stringified more readably in log messages.
	*/
	#define set_config_flag(scheduler, option, flag) do { \
	GHashTable *config_hash = (scheduler)->config_hash; \
	const char *scf_value = pcmk__cluster_option(config_hash, (option)); \
	\
	if (scf_value != NULL) { \
	if (crm_is_true(scf_value)) { \
	(scheduler)->flags = pcmk__set_flags_as(__func__, __LINE__, \
	LOG_TRACE, "Scheduler", \
	crm_system_name, (scheduler)->flags, \
	(flag), #flag); \
	} else { \
	(scheduler)->flags = pcmk__clear_flags_as(__func__, __LINE__, \
	LOG_TRACE, "Scheduler", \
	crm_system_name, (scheduler)->flags, \
	(flag), #flag); \
	} \
	} \
	} while(0)

	static void unpack_rsc_op(pcmk_resource_t rsc, pcmk_node_t node,
	xmlNode xml_op, xmlNode *last_failure,
	enum pcmk__on_fail *failed);
	static void determine_remote_online_status(pcmk_scheduler_t *scheduler,
	pcmk_node_t *this_node);
	static void add_node_attrs(const xmlNode xml_obj, pcmk_node_t node,
	bool overwrite, pcmk_scheduler_t *scheduler);
	static void determine_online_status(const xmlNode *node_state,
	pcmk_node_t *this_node,
	pcmk_scheduler_t *scheduler);

	static void unpack_node_lrm(pcmk_node_t node, const xmlNode xml,
	pcmk_scheduler_t *scheduler);


	/*!
	* \internal
	* \brief Check whether a node is a dangling guest node
	*
	* \param[in] node Node to check
	*
	* \return true if \p node had a Pacemaker Remote connection resource with a
	* launcher that was removed from the CIB, otherwise false.
	*/
	static bool
	is_dangling_guest_node(pcmk_node_t *node)
	{
	return pcmk__is_pacemaker_remote_node(node)
	&& (node->private->remote != NULL)
	&& (node->private->remote->private->launcher == NULL)
	&& pcmk_is_set(node->private->remote->flags,
	pcmk__rsc_removed_launched);
	}

	/*!
	* \brief Schedule a fence action for a node
	*
	* \param[in,out] scheduler Scheduler data
	* \param[in,out] node Node to fence
	* \param[in] reason Text description of why fencing is needed
	* \param[in] priority_delay Whether to consider
	* \c PCMK_OPT_PRIORITY_FENCING_DELAY
	*/
	void
	pe_fence_node(pcmk_scheduler_t scheduler, pcmk_node_t node,
	const char *reason, bool priority_delay)
	{
	CRM_CHECK(node, return);

	if (pcmk__is_guest_or_bundle_node(node)) {
	// Fence a guest or bundle node by marking its launcher as failed
	pcmk_resource_t *rsc = node->private->remote->private->launcher;

	if (!pcmk_is_set(rsc->flags, pcmk__rsc_failed)) {
	if (!pcmk_is_set(rsc->flags, pcmk__rsc_managed)) {
	crm_notice("Not fencing guest node %s "
	"(otherwise would because %s): "
	"its guest resource %s is unmanaged",
	pcmk__node_name(node), reason, rsc->id);
	} else {
	pcmk__sched_warn("Guest node %s will be fenced "
	"(by recovering its guest resource %s): %s",
	pcmk__node_name(node), rsc->id, reason);

	/* We don't mark the node as unclean because that would prevent the
	* node from running resources. We want to allow it to run resources
	* in this transition if the recovery succeeds.
	*/
	pcmk__set_node_flags(node, pcmk__node_remote_reset);
	pcmk__set_rsc_flags(rsc,
	pcmk__rsc_failed\|pcmk__rsc_stop_if_failed);
	}
	}

	} else if (is_dangling_guest_node(node)) {
	crm_info("Cleaning up dangling connection for guest node %s: "
	"fencing was already done because %s, "
	"and guest resource no longer exists",
	pcmk__node_name(node), reason);
	pcmk__set_rsc_flags(node->private->remote,
	pcmk__rsc_failed\|pcmk__rsc_stop_if_failed);

	} else if (pcmk__is_remote_node(node)) {
	pcmk_resource_t *rsc = node->private->remote;

	if ((rsc != NULL) && !pcmk_is_set(rsc->flags, pcmk__rsc_managed)) {
	crm_notice("Not fencing remote node %s "
	"(otherwise would because %s): connection is unmanaged",
	pcmk__node_name(node), reason);
	} else if (!pcmk_is_set(node->private->flags, pcmk__node_remote_reset)) {
	pcmk__set_node_flags(node, pcmk__node_remote_reset);
	pcmk__sched_warn("Remote node %s %s: %s",
	pcmk__node_name(node),
	pe_can_fence(scheduler, node)? "will be fenced" : "is unclean",
	reason);
	}
	node->details->unclean = TRUE;
	// No need to apply PCMK_OPT_PRIORITY_FENCING_DELAY for remote nodes
	pe_fence_op(node, NULL, TRUE, reason, FALSE, scheduler);

	} else if (node->details->unclean) {
	crm_trace("Cluster node %s %s because %s",
	pcmk__node_name(node),
	pe_can_fence(scheduler, node)? "would also be fenced" : "also is unclean",
	reason);

	} else {
	pcmk__sched_warn("Cluster node %s %s: %s",
	pcmk__node_name(node),
	pe_can_fence(scheduler, node)? "will be fenced" : "is unclean",
	reason);
	node->details->unclean = TRUE;
	pe_fence_op(node, NULL, TRUE, reason, priority_delay, scheduler);
	}
	}

	// @TODO xpaths can't handle templates, rules, or id-refs

	// nvpair with provides or requires set to unfencing
	#define XPATH_UNFENCING_NVPAIR PCMK_XE_NVPAIR \
	"[(@" PCMK_XA_NAME "='" PCMK_STONITH_PROVIDES "'" \
	"or @" PCMK_XA_NAME "='" PCMK_META_REQUIRES "') " \
	"and @" PCMK_XA_VALUE "='" PCMK_VALUE_UNFENCING "']"

	// unfencing in rsc_defaults or any resource
	#define XPATH_ENABLE_UNFENCING \
	"/" PCMK_XE_CIB "/" PCMK_XE_CONFIGURATION "/" PCMK_XE_RESOURCES \
	"//" PCMK_XE_META_ATTRIBUTES "/" XPATH_UNFENCING_NVPAIR \
	"\|/" PCMK_XE_CIB "/" PCMK_XE_CONFIGURATION "/" PCMK_XE_RSC_DEFAULTS \
	"/" PCMK_XE_META_ATTRIBUTES "/" XPATH_UNFENCING_NVPAIR

	static void
	set_if_xpath(uint64_t flag, const char xpath, pcmk_scheduler_t scheduler)
	{
	xmlXPathObjectPtr result = NULL;

	if (!pcmk_is_set(scheduler->flags, flag)) {
	result = xpath_search(scheduler->input, xpath);
	if (result && (numXpathResults(result) > 0)) {
	pcmk__set_scheduler_flags(scheduler, flag);
	}
	freeXpathObject(result);
	}
	}

	gboolean
	unpack_config(xmlNode config, pcmk_scheduler_t scheduler)
	{
	const char *value = NULL;
	guint interval_ms = 0U;
	GHashTable *config_hash = pcmk__strkey_table(free, free);

	pe_rule_eval_data_t rule_data = {
	.node_hash = NULL,
	.now = scheduler->now,
	.match_data = NULL,
	.rsc_data = NULL,
	.op_data = NULL
	};

	scheduler->config_hash = config_hash;

	pe__unpack_dataset_nvpairs(config, PCMK_XE_CLUSTER_PROPERTY_SET, &rule_data,
	config_hash, PCMK_VALUE_CIB_BOOTSTRAP_OPTIONS,
	FALSE, scheduler);

	pcmk__validate_cluster_options(config_hash);

	set_config_flag(scheduler, PCMK_OPT_ENABLE_STARTUP_PROBES,
	pcmk_sched_probe_resources);
	if (!pcmk_is_set(scheduler->flags, pcmk_sched_probe_resources)) {
	crm_info("Startup probes: disabled (dangerous)");
	}

	value = pcmk__cluster_option(config_hash, PCMK_OPT_HAVE_WATCHDOG);
	if (value && crm_is_true(value)) {
	crm_info("Watchdog-based self-fencing will be performed via SBD if "
	"fencing is required and " PCMK_OPT_STONITH_WATCHDOG_TIMEOUT
	" is nonzero");
	pcmk__set_scheduler_flags(scheduler, pcmk_sched_have_fencing);
	}

	/* Set certain flags via xpath here, so they can be used before the relevant
	* configuration sections are unpacked.
	*/
	set_if_xpath(pcmk_sched_enable_unfencing, XPATH_ENABLE_UNFENCING,
	scheduler);

	value = pcmk__cluster_option(config_hash, PCMK_OPT_STONITH_TIMEOUT);
	pcmk_parse_interval_spec(value, &interval_ms);

	if (interval_ms >= INT_MAX) {
	scheduler->stonith_timeout = INT_MAX;
	} else {
	scheduler->stonith_timeout = (int) interval_ms;
	}
	crm_debug("STONITH timeout: %d", scheduler->stonith_timeout);

	set_config_flag(scheduler, PCMK_OPT_STONITH_ENABLED,
	pcmk_sched_fencing_enabled);
	if (pcmk_is_set(scheduler->flags, pcmk_sched_fencing_enabled)) {
	crm_debug("STONITH of failed nodes is enabled");
	} else {
	crm_debug("STONITH of failed nodes is disabled");
	}

	scheduler->stonith_action = pcmk__cluster_option(config_hash,
	PCMK_OPT_STONITH_ACTION);
	if (!strcmp(scheduler->stonith_action, PCMK__ACTION_POWEROFF)) {
	pcmk__warn_once(pcmk__wo_poweroff,
	"Support for " PCMK_OPT_STONITH_ACTION " of "
	"'" PCMK__ACTION_POWEROFF "' is deprecated and will be "
	"removed in a future release "
	"(use '" PCMK_ACTION_OFF "' instead)");
	scheduler->stonith_action = PCMK_ACTION_OFF;
	}
	crm_trace("STONITH will %s nodes", scheduler->stonith_action);

	set_config_flag(scheduler, PCMK_OPT_CONCURRENT_FENCING,
	pcmk_sched_concurrent_fencing);
	if (pcmk_is_set(scheduler->flags, pcmk_sched_concurrent_fencing)) {
	crm_debug("Concurrent fencing is enabled");
	} else {
	crm_debug("Concurrent fencing is disabled");
	}

	value = pcmk__cluster_option(config_hash, PCMK_OPT_PRIORITY_FENCING_DELAY);
	if (value) {
	pcmk_parse_interval_spec(value, &interval_ms);
	scheduler->priority_fencing_delay = (int) (interval_ms / 1000);
	crm_trace("Priority fencing delay is %ds",
	scheduler->priority_fencing_delay);
	}

	set_config_flag(scheduler, PCMK_OPT_STOP_ALL_RESOURCES,
	pcmk_sched_stop_all);
	crm_debug("Stop all active resources: %s",
	pcmk__flag_text(scheduler->flags, pcmk_sched_stop_all));

	set_config_flag(scheduler, PCMK_OPT_SYMMETRIC_CLUSTER,
	pcmk_sched_symmetric_cluster);
	if (pcmk_is_set(scheduler->flags, pcmk_sched_symmetric_cluster)) {
	crm_debug("Cluster is symmetric" " - resources can run anywhere by default");
	}

	value = pcmk__cluster_option(config_hash, PCMK_OPT_NO_QUORUM_POLICY);

	if (pcmk__str_eq(value, PCMK_VALUE_IGNORE, pcmk__str_casei)) {
	scheduler->no_quorum_policy = pcmk_no_quorum_ignore;

	} else if (pcmk__str_eq(value, PCMK_VALUE_FREEZE, pcmk__str_casei)) {
	scheduler->no_quorum_policy = pcmk_no_quorum_freeze;

	} else if (pcmk__str_eq(value, PCMK_VALUE_DEMOTE, pcmk__str_casei)) {
	scheduler->no_quorum_policy = pcmk_no_quorum_demote;

	} else if (pcmk__str_eq(value, PCMK_VALUE_FENCE_LEGACY, pcmk__str_casei)) {
	if (pcmk_is_set(scheduler->flags, pcmk_sched_fencing_enabled)) {
	int do_panic = 0;

	crm_element_value_int(scheduler->input, PCMK_XA_NO_QUORUM_PANIC,
	&do_panic);
	if (do_panic \|\| pcmk_is_set(scheduler->flags, pcmk_sched_quorate)) {
	scheduler->no_quorum_policy = pcmk_no_quorum_fence;
	} else {
	crm_notice("Resetting " PCMK_OPT_NO_QUORUM_POLICY
	" to 'stop': cluster has never had quorum");
	scheduler->no_quorum_policy = pcmk_no_quorum_stop;
	}
	} else {
	pcmk__config_err("Resetting " PCMK_OPT_NO_QUORUM_POLICY
	" to 'stop' because fencing is disabled");
	scheduler->no_quorum_policy = pcmk_no_quorum_stop;
	}

	} else {
	scheduler->no_quorum_policy = pcmk_no_quorum_stop;
	}

	switch (scheduler->no_quorum_policy) {
	case pcmk_no_quorum_freeze:
	crm_debug("On loss of quorum: Freeze resources");
	break;
	case pcmk_no_quorum_stop:
	crm_debug("On loss of quorum: Stop ALL resources");
	break;
	case pcmk_no_quorum_demote:
	crm_debug("On loss of quorum: "
	"Demote promotable resources and stop other resources");
	break;
	case pcmk_no_quorum_fence:
	crm_notice("On loss of quorum: Fence all remaining nodes");
	break;
	case pcmk_no_quorum_ignore:
	crm_notice("On loss of quorum: Ignore");
	break;
	}

	set_config_flag(scheduler, PCMK_OPT_STOP_ORPHAN_RESOURCES,
	pcmk_sched_stop_removed_resources);
	if (pcmk_is_set(scheduler->flags, pcmk_sched_stop_removed_resources)) {
	crm_trace("Orphan resources are stopped");
	} else {
	crm_trace("Orphan resources are ignored");
	}

	set_config_flag(scheduler, PCMK_OPT_STOP_ORPHAN_ACTIONS,
	pcmk_sched_cancel_removed_actions);
	if (pcmk_is_set(scheduler->flags, pcmk_sched_cancel_removed_actions)) {
	crm_trace("Orphan resource actions are stopped");
	} else {
	crm_trace("Orphan resource actions are ignored");
	}

	value = pcmk__cluster_option(config_hash, PCMK__OPT_REMOVE_AFTER_STOP);
	if (value != NULL) {
	if (crm_is_true(value)) {
	pcmk__set_scheduler_flags(scheduler, pcmk_sched_remove_after_stop);
	pcmk__warn_once(pcmk__wo_remove_after,
	"Support for the " PCMK__OPT_REMOVE_AFTER_STOP
	" cluster property is deprecated and will be "
	"removed in a future release");
	} else {
	pcmk__clear_scheduler_flags(scheduler,
	pcmk_sched_remove_after_stop);
	}
	}

	set_config_flag(scheduler, PCMK_OPT_MAINTENANCE_MODE,
	pcmk_sched_in_maintenance);
	crm_trace("Maintenance mode: %s",
	pcmk__flag_text(scheduler->flags, pcmk_sched_in_maintenance));

	set_config_flag(scheduler, PCMK_OPT_START_FAILURE_IS_FATAL,
	pcmk_sched_start_failure_fatal);
	if (pcmk_is_set(scheduler->flags, pcmk_sched_start_failure_fatal)) {
	crm_trace("Start failures are always fatal");
	} else {
	crm_trace("Start failures are handled by failcount");
	}

	if (pcmk_is_set(scheduler->flags, pcmk_sched_fencing_enabled)) {
	set_config_flag(scheduler, PCMK_OPT_STARTUP_FENCING,
	pcmk_sched_startup_fencing);
	}
	if (pcmk_is_set(scheduler->flags, pcmk_sched_startup_fencing)) {
	crm_trace("Unseen nodes will be fenced");
	} else {
	pcmk__warn_once(pcmk__wo_blind,
	"Blind faith: not fencing unseen nodes");
	}

	pe__unpack_node_health_scores(scheduler);

	scheduler->placement_strategy =
	pcmk__cluster_option(config_hash, PCMK_OPT_PLACEMENT_STRATEGY);
	crm_trace("Placement strategy: %s", scheduler->placement_strategy);

	set_config_flag(scheduler, PCMK_OPT_SHUTDOWN_LOCK,
	pcmk_sched_shutdown_lock);
	if (pcmk_is_set(scheduler->flags, pcmk_sched_shutdown_lock)) {
	value = pcmk__cluster_option(config_hash, PCMK_OPT_SHUTDOWN_LOCK_LIMIT);
	pcmk_parse_interval_spec(value, &(scheduler->shutdown_lock));
	scheduler->shutdown_lock /= 1000;
	crm_trace("Resources will be locked to nodes that were cleanly "
	"shut down (locks expire after %s)",
	pcmk__readable_interval(scheduler->shutdown_lock));
	} else {
	crm_trace("Resources will not be locked to nodes that were cleanly "
	"shut down");
	}

	value = pcmk__cluster_option(config_hash, PCMK_OPT_NODE_PENDING_TIMEOUT);
	pcmk_parse_interval_spec(value, &(scheduler->node_pending_timeout));
	scheduler->node_pending_timeout /= 1000;
	if (scheduler->node_pending_timeout == 0) {
	crm_trace("Do not fence pending nodes");
	} else {
	crm_trace("Fence pending nodes after %s",
	pcmk__readable_interval(scheduler->node_pending_timeout
	* 1000));
	}

	return TRUE;
	}

	pcmk_node_t *
	pe_create_node(const char id, const char uname, const char *type,
	const char score, pcmk_scheduler_t scheduler)
	{
	pcmk_node_t *new_node = NULL;

	if (pcmk_find_node(scheduler, uname) != NULL) {
	pcmk__config_warn("More than one node entry has name '%s'", uname);
	}

	new_node = calloc(1, sizeof(pcmk_node_t));
	if (new_node == NULL) {
	pcmk__sched_err("Could not allocate memory for node %s", uname);
	return NULL;
	}

	new_node->assign = calloc(1, sizeof(struct pcmk__node_assignment));
	new_node->details = calloc(1, sizeof(struct pcmk__node_details));
	new_node->private = calloc(1, sizeof(pcmk__node_private_t));
	if ((new_node->assign == NULL) \|\| (new_node->details == NULL)
	\|\| (new_node->private == NULL)) {
	free(new_node->assign);
	free(new_node->details);
	free(new_node->private);
	free(new_node);
	pcmk__sched_err("Could not allocate memory for node %s", uname);
	return NULL;
	}

	crm_trace("Creating node for entry %s/%s", uname, id);
	new_node->assign->score = char2score(score);
	new_node->private->id = id;
	new_node->private->name = uname;
	new_node->private->flags = pcmk__node_probes_allowed;
	new_node->details->online = FALSE;
	new_node->details->shutdown = FALSE;
	new_node->details->running_rsc = NULL;
	new_node->private->scheduler = scheduler;

	if (pcmk__str_eq(type, PCMK_VALUE_MEMBER,
	pcmk__str_null_matches\|pcmk__str_casei)) {
	new_node->private->variant = pcmk__node_variant_cluster;

	} else if (pcmk__str_eq(type, PCMK_VALUE_REMOTE, pcmk__str_casei)) {
	new_node->private->variant = pcmk__node_variant_remote;
	pcmk__set_scheduler_flags(scheduler, pcmk_sched_have_remote_nodes);

	} else {
	/* @COMPAT 'ping' is the default for backward compatibility, but it
	* should be changed to 'member' at a compatibility break
	*/
	if (!pcmk__str_eq(type, PCMK__VALUE_PING, pcmk__str_casei)) {
	pcmk__config_warn("Node %s has unrecognized type '%s', "
	"assuming '" PCMK__VALUE_PING "'",
	pcmk__s(uname, "without name"), type);
	}
	pcmk__warn_once(pcmk__wo_ping_node,
	"Support for nodes of type '" PCMK__VALUE_PING "' "
	"(such as %s) is deprecated and will be removed in a "
	"future release",
	pcmk__s(uname, "unnamed node"));
	new_node->private->variant = pcmk__node_variant_ping;
	}

	new_node->private->attrs = pcmk__strkey_table(free, free);

	if (pcmk__is_pacemaker_remote_node(new_node)) {
	pcmk__insert_dup(new_node->private->attrs, CRM_ATTR_KIND, "remote");
	} else {
	pcmk__insert_dup(new_node->private->attrs, CRM_ATTR_KIND, "cluster");
	}

	new_node->private->utilization = pcmk__strkey_table(free, free);
	new_node->private->digest_cache = pcmk__strkey_table(free,
	pe__free_digests);

	scheduler->nodes = g_list_insert_sorted(scheduler->nodes, new_node,
	pe__cmp_node_name);
	return new_node;
	}

	static const char *
	expand_remote_rsc_meta(xmlNode xml_obj, xmlNode parent, pcmk_scheduler_t *data)
	{
	xmlNode *attr_set = NULL;
	xmlNode *attr = NULL;

	const char *container_id = pcmk__xe_id(xml_obj);
	const char *remote_name = NULL;
	const char *remote_server = NULL;
	const char *remote_port = NULL;
	const char *connect_timeout = "60s";
	const char *remote_allow_migrate=NULL;
	const char *is_managed = NULL;

	for (attr_set = pcmk__xe_first_child(xml_obj, NULL, NULL, NULL);
	attr_set != NULL; attr_set = pcmk__xe_next(attr_set)) {

	if (!pcmk__xe_is(attr_set, PCMK_XE_META_ATTRIBUTES)) {
	continue;
	}

	for (attr = pcmk__xe_first_child(attr_set, NULL, NULL, NULL);
	attr != NULL; attr = pcmk__xe_next(attr)) {

	const char *value = crm_element_value(attr, PCMK_XA_VALUE);
	const char *name = crm_element_value(attr, PCMK_XA_NAME);

	if (name == NULL) { // Sanity
	continue;
	}

	if (strcmp(name, PCMK_META_REMOTE_NODE) == 0) {
	remote_name = value;

	} else if (strcmp(name, PCMK_META_REMOTE_ADDR) == 0) {
	remote_server = value;

	} else if (strcmp(name, PCMK_META_REMOTE_PORT) == 0) {
	remote_port = value;

	} else if (strcmp(name, PCMK_META_REMOTE_CONNECT_TIMEOUT) == 0) {
	connect_timeout = value;

	} else if (strcmp(name, PCMK_META_REMOTE_ALLOW_MIGRATE) == 0) {
	remote_allow_migrate = value;

	} else if (strcmp(name, PCMK_META_IS_MANAGED) == 0) {
	is_managed = value;
	}
	}
	}

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

	if (pe_find_resource(data->resources, remote_name) != NULL) {
	return NULL;
	}

	pe_create_remote_xml(parent, remote_name, container_id,
	remote_allow_migrate, is_managed,
	connect_timeout, remote_server, remote_port);
	return remote_name;
	}

	static void
	handle_startup_fencing(pcmk_scheduler_t scheduler, pcmk_node_t new_node)
	{
	if ((new_node->private->variant == pcmk__node_variant_remote)
	&& (new_node->private->remote == NULL)) {
	/* Ignore fencing for remote nodes that don't have a connection resource
	* associated with them. This happens when remote node entries get left
	* in the nodes section after the connection resource is removed.
	*/
	return;
	}

	if (pcmk_is_set(scheduler->flags, pcmk_sched_startup_fencing)) {
	// All nodes are unclean until we've seen their status entry
	new_node->details->unclean = TRUE;

	} else {
	// Blind faith ...
	new_node->details->unclean = FALSE;
	}
	}

	gboolean
	unpack_nodes(xmlNode xml_nodes, pcmk_scheduler_t scheduler)
	{
	xmlNode *xml_obj = NULL;
	pcmk_node_t *new_node = NULL;
	const char *id = NULL;
	const char *uname = NULL;
	const char *type = NULL;
	const char *score = NULL;

	for (xml_obj = pcmk__xe_first_child(xml_nodes, NULL, NULL, NULL);
	xml_obj != NULL; xml_obj = pcmk__xe_next(xml_obj)) {

	if (pcmk__xe_is(xml_obj, PCMK_XE_NODE)) {
	new_node = NULL;

	id = crm_element_value(xml_obj, PCMK_XA_ID);
	uname = crm_element_value(xml_obj, PCMK_XA_UNAME);
	type = crm_element_value(xml_obj, PCMK_XA_TYPE);
	score = crm_element_value(xml_obj, PCMK_XA_SCORE);
	crm_trace("Processing node %s/%s", uname, id);

	if (id == NULL) {
	pcmk__config_err("Ignoring <" PCMK_XE_NODE
	"> entry in configuration without id");
	continue;
	}
	new_node = pe_create_node(id, uname, type, score, scheduler);

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

	handle_startup_fencing(scheduler, new_node);

	add_node_attrs(xml_obj, new_node, FALSE, scheduler);

	crm_trace("Done with node %s",
	crm_element_value(xml_obj, PCMK_XA_UNAME));
	}
	}

	if (scheduler->localhost
	&& (pcmk_find_node(scheduler, scheduler->localhost) == NULL)) {
	crm_info("Creating a fake local node");
	pe_create_node(scheduler->localhost, scheduler->localhost, NULL, 0,
	scheduler);
	}

	return TRUE;
	}

	static void
	unpack_launcher(pcmk_resource_t rsc, pcmk_scheduler_t scheduler)
	{
	const char *launcher_id = NULL;

	if (rsc->private->children != NULL) {
	g_list_foreach(rsc->private->children, (GFunc) unpack_launcher,
	scheduler);
	return;
	}

	launcher_id = g_hash_table_lookup(rsc->private->meta, PCMK__META_CONTAINER);
	if ((launcher_id != NULL)
	&& !pcmk__str_eq(launcher_id, rsc->id, pcmk__str_none)) {
	pcmk_resource_t *launcher = pe_find_resource(scheduler->resources,
	launcher_id);

	if (launcher != NULL) {
	rsc->private->launcher = launcher;
	launcher->private->launched =
	g_list_append(launcher->private->launched, rsc);
	pcmk__rsc_trace(rsc, "Resource %s's launcher is %s",
	rsc->id, launcher_id);
	} else {
	pcmk__config_err("Resource %s: Unknown " PCMK__META_CONTAINER " %s",
	rsc->id, launcher_id);
	}
	}
	}

	gboolean
	unpack_remote_nodes(xmlNode xml_resources, pcmk_scheduler_t scheduler)
	{
	xmlNode *xml_obj = NULL;

	/* Create remote nodes and guest nodes from the resource configuration
	* before unpacking resources.
	*/
	for (xml_obj = pcmk__xe_first_child(xml_resources, NULL, NULL, NULL);
	xml_obj != NULL; xml_obj = pcmk__xe_next(xml_obj)) {

	const char *new_node_id = NULL;

	/* Check for remote nodes, which are defined by ocf:pacemaker:remote
	* primitives.
	*/
	if (xml_contains_remote_node(xml_obj)) {
	new_node_id = pcmk__xe_id(xml_obj);
	/* The pcmk_find_node() check ensures we don't iterate over an
	* expanded node that has already been added to the node list
	*/
	if (new_node_id
	&& (pcmk_find_node(scheduler, new_node_id) == NULL)) {
	crm_trace("Found remote node %s defined by resource %s",
	new_node_id, pcmk__xe_id(xml_obj));
	pe_create_node(new_node_id, new_node_id, PCMK_VALUE_REMOTE,
	NULL, scheduler);
	}
	continue;
	}

	/* Check for guest nodes, which are defined by special meta-attributes
	* of a primitive of any type (for example, VirtualDomain or Xen).
	*/
	if (pcmk__xe_is(xml_obj, PCMK_XE_PRIMITIVE)) {
	/* This will add an ocf:pacemaker:remote primitive to the
	* configuration for the guest node's connection, to be unpacked
	* later.
	*/
	new_node_id = expand_remote_rsc_meta(xml_obj, xml_resources,
	scheduler);
	if (new_node_id
	&& (pcmk_find_node(scheduler, new_node_id) == NULL)) {
	crm_trace("Found guest node %s in resource %s",
	new_node_id, pcmk__xe_id(xml_obj));
	pe_create_node(new_node_id, new_node_id, PCMK_VALUE_REMOTE,
	NULL, scheduler);
	}
	continue;
	}

	/* Check for guest nodes inside a group. Clones are currently not
	* supported as guest nodes.
	*/
	if (pcmk__xe_is(xml_obj, PCMK_XE_GROUP)) {
	xmlNode *xml_obj2 = NULL;
	for (xml_obj2 = pcmk__xe_first_child(xml_obj, NULL, NULL, NULL);
	xml_obj2 != NULL; xml_obj2 = pcmk__xe_next(xml_obj2)) {

	new_node_id = expand_remote_rsc_meta(xml_obj2, xml_resources,
	scheduler);

	if (new_node_id
	&& (pcmk_find_node(scheduler, new_node_id) == NULL)) {
	crm_trace("Found guest node %s in resource %s inside group %s",
	new_node_id, pcmk__xe_id(xml_obj2),
	pcmk__xe_id(xml_obj));
	pe_create_node(new_node_id, new_node_id, PCMK_VALUE_REMOTE,
	NULL, scheduler);
	}
	}
	}
	}
	return TRUE;
	}

	/* Call this after all the nodes and resources have been
	* unpacked, but before the status section is read.
	*
	* A remote node's online status is reflected by the state
	* of the remote node's connection resource. We need to link
	* the remote node to this connection resource so we can have
	* easy access to the connection resource during the scheduler calculations.
	*/
	static void
	link_rsc2remotenode(pcmk_scheduler_t scheduler, pcmk_resource_t new_rsc)
	{
	pcmk_node_t *remote_node = NULL;

	if (!pcmk_is_set(new_rsc->flags, pcmk__rsc_is_remote_connection)) {
	return;
	}

	if (pcmk_is_set(scheduler->flags, pcmk_sched_location_only)) {
	/* remote_nodes and remote_resources are not linked in quick location calculations */
	return;
	}

	remote_node = pcmk_find_node(scheduler, new_rsc->id);
	CRM_CHECK(remote_node != NULL, return);

	pcmk__rsc_trace(new_rsc, "Linking remote connection resource %s to %s",
	new_rsc->id, pcmk__node_name(remote_node));
	remote_node->private->remote = new_rsc;

	if (new_rsc->private->launcher == NULL) {
	/* Handle start-up fencing for remote nodes (as opposed to guest nodes)
	* the same as is done for cluster nodes.
	*/
	handle_startup_fencing(scheduler, remote_node);

	} else {
	/* pe_create_node() marks the new node as "remote" or "cluster"; now
	* that we know the node is a guest node, update it correctly.
	*/
	pcmk__insert_dup(remote_node->private->attrs,
	CRM_ATTR_KIND, "container");
	}
	}

	/*!
	* \internal
	* \brief Parse configuration XML for resource information
	*
	* \param[in] xml_resources Top of resource configuration XML
	* \param[in,out] scheduler Scheduler data
	*
	* \return TRUE
	*
	* \note unpack_remote_nodes() MUST be called before this, so that the nodes can
	* be used when pe__unpack_resource() calls resource_location()
	*/
	gboolean
	unpack_resources(const xmlNode xml_resources, pcmk_scheduler_t scheduler)
	{
	xmlNode *xml_obj = NULL;
	GList *gIter = NULL;

	scheduler->template_rsc_sets = pcmk__strkey_table(free, pcmk__free_idref);

	for (xml_obj = pcmk__xe_first_child(xml_resources, NULL, NULL, NULL);
	xml_obj != NULL; xml_obj = pcmk__xe_next(xml_obj)) {

	pcmk_resource_t *new_rsc = NULL;
	const char *id = pcmk__xe_id(xml_obj);

	if (pcmk__str_empty(id)) {
	pcmk__config_err("Ignoring <%s> resource without ID",
	xml_obj->name);
	continue;
	}

	if (pcmk__xe_is(xml_obj, PCMK_XE_TEMPLATE)) {
	if (g_hash_table_lookup_extended(scheduler->template_rsc_sets, id,
	NULL, NULL) == FALSE) {
	/* Record the template's ID for the knowledge of its existence anyway. */
	pcmk__insert_dup(scheduler->template_rsc_sets, id, NULL);
	}
	continue;
	}

	crm_trace("Unpacking <%s " PCMK_XA_ID "='%s'>", xml_obj->name, id);
	if (pe__unpack_resource(xml_obj, &new_rsc, NULL,
	scheduler) == pcmk_rc_ok) {
	scheduler->resources = g_list_append(scheduler->resources, new_rsc);
	pcmk__rsc_trace(new_rsc, "Added resource %s", new_rsc->id);

	} else {
	pcmk__config_err("Ignoring <%s> resource '%s' "
	"because configuration is invalid",
	xml_obj->name, id);
	}
	}

	for (gIter = scheduler->resources; gIter != NULL; gIter = gIter->next) {
	pcmk_resource_t rsc = (pcmk_resource_t ) gIter->data;

	unpack_launcher(rsc, scheduler);
	link_rsc2remotenode(scheduler, rsc);
	}

	scheduler->resources = g_list_sort(scheduler->resources,
	pe__cmp_rsc_priority);
	if (pcmk_is_set(scheduler->flags, pcmk_sched_location_only)) {
	/* Ignore */

	} else if (pcmk_is_set(scheduler->flags, pcmk_sched_fencing_enabled)
	&& !pcmk_is_set(scheduler->flags, pcmk_sched_have_fencing)) {

	pcmk__config_err("Resource start-up disabled since no STONITH resources have been defined");
	pcmk__config_err("Either configure some or disable STONITH with the "
	PCMK_OPT_STONITH_ENABLED " option");
	pcmk__config_err("NOTE: Clusters with shared data need STONITH to ensure data integrity");
	}

	return TRUE;
	}

	gboolean
	unpack_tags(xmlNode xml_tags, pcmk_scheduler_t scheduler)
	{
	xmlNode *xml_tag = NULL;

	scheduler->tags = pcmk__strkey_table(free, pcmk__free_idref);

	for (xml_tag = pcmk__xe_first_child(xml_tags, NULL, NULL, NULL);
	xml_tag != NULL; xml_tag = pcmk__xe_next(xml_tag)) {

	xmlNode *xml_obj_ref = NULL;
	const char *tag_id = pcmk__xe_id(xml_tag);

	if (!pcmk__xe_is(xml_tag, PCMK_XE_TAG)) {
	continue;
	}

	if (tag_id == NULL) {
	pcmk__config_err("Ignoring <%s> without " PCMK_XA_ID,
	(const char *) xml_tag->name);
	continue;
	}

	for (xml_obj_ref = pcmk__xe_first_child(xml_tag, NULL, NULL, NULL);
	xml_obj_ref != NULL; xml_obj_ref = pcmk__xe_next(xml_obj_ref)) {

	const char *obj_ref = pcmk__xe_id(xml_obj_ref);

	if (!pcmk__xe_is(xml_obj_ref, PCMK_XE_OBJ_REF)) {
	continue;
	}

	if (obj_ref == NULL) {
	pcmk__config_err("Ignoring <%s> for tag '%s' without " PCMK_XA_ID,
	xml_obj_ref->name, tag_id);
	continue;
	}

	pcmk__add_idref(scheduler->tags, tag_id, obj_ref);
	}
	}

	return TRUE;
	}

	/* The ticket state section:
	* "/cib/status/tickets/ticket_state" */
	static gboolean
	unpack_ticket_state(xmlNode xml_ticket, pcmk_scheduler_t scheduler)
	{
	const char *ticket_id = NULL;
	const char *granted = NULL;
	const char *last_granted = NULL;
	const char *standby = NULL;
	xmlAttrPtr xIter = NULL;

	pcmk__ticket_t *ticket = NULL;

	ticket_id = pcmk__xe_id(xml_ticket);
	if (pcmk__str_empty(ticket_id)) {
	return FALSE;
	}

	crm_trace("Processing ticket state for %s", ticket_id);

	ticket = g_hash_table_lookup(scheduler->tickets, ticket_id);
	if (ticket == NULL) {
	ticket = ticket_new(ticket_id, scheduler);
	if (ticket == NULL) {
	return FALSE;
	}
	}

	for (xIter = xml_ticket->properties; xIter; xIter = xIter->next) {
	const char prop_name = (const char )xIter->name;
	const char *prop_value = pcmk__xml_attr_value(xIter);

	if (pcmk__str_eq(prop_name, PCMK_XA_ID, pcmk__str_none)) {
	continue;
	}
	pcmk__insert_dup(ticket->state, prop_name, prop_value);
	}

	granted = g_hash_table_lookup(ticket->state, PCMK__XA_GRANTED);
	if (granted && crm_is_true(granted)) {
	- ticket->granted = TRUE;
	+ pcmk__set_ticket_flags(ticket, pcmk__ticket_granted);
	crm_info("We have ticket '%s'", ticket->id);
	} else {
	- ticket->granted = FALSE;
	+ pcmk__clear_ticket_flags(ticket, pcmk__ticket_granted);
	crm_info("We do not have ticket '%s'", ticket->id);
	}

	last_granted = g_hash_table_lookup(ticket->state, PCMK_XA_LAST_GRANTED);
	if (last_granted) {
	long long last_granted_ll;

	pcmk__scan_ll(last_granted, &last_granted_ll, 0LL);
	ticket->last_granted = (time_t) last_granted_ll;
	}

	standby = g_hash_table_lookup(ticket->state, PCMK_XA_STANDBY);
	if (standby && crm_is_true(standby)) {
	- ticket->standby = TRUE;
	- if (ticket->granted) {
	+ pcmk__set_ticket_flags(ticket, pcmk__ticket_standby);
	+ if (pcmk_is_set(ticket->flags, pcmk__ticket_granted)) {
	crm_info("Granted ticket '%s' is in standby-mode", ticket->id);
	}
	} else {
	- ticket->standby = FALSE;
	+ pcmk__clear_ticket_flags(ticket, pcmk__ticket_standby);
	}

	crm_trace("Done with ticket state for %s", ticket_id);

	return TRUE;
	}

	static gboolean
	unpack_tickets_state(xmlNode xml_tickets, pcmk_scheduler_t scheduler)
	{
	xmlNode *xml_obj = NULL;

	for (xml_obj = pcmk__xe_first_child(xml_tickets, NULL, NULL, NULL);
	xml_obj != NULL; xml_obj = pcmk__xe_next(xml_obj)) {

	if (!pcmk__xe_is(xml_obj, PCMK__XE_TICKET_STATE)) {
	continue;
	}
	unpack_ticket_state(xml_obj, scheduler);
	}

	return TRUE;
	}

	static void
	unpack_handle_remote_attrs(pcmk_node_t this_node, const xmlNode state,
	pcmk_scheduler_t *scheduler)
	{
	const char *discovery = NULL;
	const xmlNode *attrs = NULL;
	pcmk_resource_t *rsc = NULL;
	int maint = 0;

	if (!pcmk__xe_is(state, PCMK__XE_NODE_STATE)) {
	return;
	}

	if ((this_node == NULL) \|\| !pcmk__is_pacemaker_remote_node(this_node)) {
	return;
	}
	crm_trace("Processing Pacemaker Remote node %s",
	pcmk__node_name(this_node));

	pcmk__scan_min_int(crm_element_value(state, PCMK__XA_NODE_IN_MAINTENANCE),
	&maint, 0);
	if (maint) {
	pcmk__set_node_flags(this_node, pcmk__node_remote_maint);
	} else {
	pcmk__clear_node_flags(this_node, pcmk__node_remote_maint);
	}

	rsc = this_node->private->remote;
	if (!pcmk_is_set(this_node->private->flags, pcmk__node_remote_reset)) {
	this_node->details->unclean = FALSE;
	pcmk__set_node_flags(this_node, pcmk__node_seen);
	}
	attrs = pcmk__xe_first_child(state, PCMK__XE_TRANSIENT_ATTRIBUTES, NULL,
	NULL);
	add_node_attrs(attrs, this_node, TRUE, scheduler);

	if (pe__shutdown_requested(this_node)) {
	crm_info("%s is shutting down", pcmk__node_name(this_node));
	this_node->details->shutdown = TRUE;
	}

	if (crm_is_true(pcmk__node_attr(this_node, PCMK_NODE_ATTR_STANDBY, NULL,
	pcmk__rsc_node_current))) {
	crm_info("%s is in standby mode", pcmk__node_name(this_node));
	pcmk__set_node_flags(this_node, pcmk__node_standby);
	}

	if (crm_is_true(pcmk__node_attr(this_node, PCMK_NODE_ATTR_MAINTENANCE, NULL,
	pcmk__rsc_node_current))
	\|\| ((rsc != NULL) && !pcmk_is_set(rsc->flags, pcmk__rsc_managed))) {
	crm_info("%s is in maintenance mode", pcmk__node_name(this_node));
	this_node->details->maintenance = TRUE;
	}

	discovery = pcmk__node_attr(this_node,
	PCMK__NODE_ATTR_RESOURCE_DISCOVERY_ENABLED,
	NULL, pcmk__rsc_node_current);
	if ((discovery != NULL) && !crm_is_true(discovery)) {
	pcmk__warn_once(pcmk__wo_rdisc_enabled,
	"Support for the "
	PCMK__NODE_ATTR_RESOURCE_DISCOVERY_ENABLED
	" node attribute is deprecated and will be removed"
	" (and behave as 'true') in a future release.");

	if (pcmk__is_remote_node(this_node)
	&& !pcmk_is_set(scheduler->flags, pcmk_sched_fencing_enabled)) {
	pcmk__config_warn("Ignoring "
	PCMK__NODE_ATTR_RESOURCE_DISCOVERY_ENABLED
	" attribute on Pacemaker Remote node %s"
	" because fencing is disabled",
	pcmk__node_name(this_node));
	} else {
	/* This is either a remote node with fencing enabled, or a guest
	* node. We don't care whether fencing is enabled when fencing guest
	* nodes, because they are "fenced" by recovering their containing
	* resource.
	*/
	crm_info("%s has resource discovery disabled",
	pcmk__node_name(this_node));
	pcmk__clear_node_flags(this_node, pcmk__node_probes_allowed);
	}
	}
	}

	/*!
	* \internal
	* \brief Unpack a cluster node's transient attributes
	*
	* \param[in] state CIB node state XML
	* \param[in,out] node Cluster node whose attributes are being unpacked
	* \param[in,out] scheduler Scheduler data
	*/
	static void
	unpack_transient_attributes(const xmlNode state, pcmk_node_t node,
	pcmk_scheduler_t *scheduler)
	{
	const char *discovery = NULL;
	const xmlNode *attrs = pcmk__xe_first_child(state,
	PCMK__XE_TRANSIENT_ATTRIBUTES,
	NULL, NULL);

	add_node_attrs(attrs, node, TRUE, scheduler);

	if (crm_is_true(pcmk__node_attr(node, PCMK_NODE_ATTR_STANDBY, NULL,
	pcmk__rsc_node_current))) {
	crm_info("%s is in standby mode", pcmk__node_name(node));
	pcmk__set_node_flags(node, pcmk__node_standby);
	}

	if (crm_is_true(pcmk__node_attr(node, PCMK_NODE_ATTR_MAINTENANCE, NULL,
	pcmk__rsc_node_current))) {
	crm_info("%s is in maintenance mode", pcmk__node_name(node));
	node->details->maintenance = TRUE;
	}

	discovery = pcmk__node_attr(node,
	PCMK__NODE_ATTR_RESOURCE_DISCOVERY_ENABLED,
	NULL, pcmk__rsc_node_current);
	if ((discovery != NULL) && !crm_is_true(discovery)) {
	pcmk__config_warn("Ignoring "
	PCMK__NODE_ATTR_RESOURCE_DISCOVERY_ENABLED
	" attribute for %s because disabling resource"
	" discovery is not allowed for cluster nodes",
	pcmk__node_name(node));
	}
	}

	/*!
	* \internal
	* \brief Unpack a node state entry (first pass)
	*
	* Unpack one node state entry from status. This unpacks information from the
	* \C PCMK__XE_NODE_STATE element itself and node attributes inside it, but not
	* the resource history inside it. Multiple passes through the status are needed
	* to fully unpack everything.
	*
	* \param[in] state CIB node state XML
	* \param[in,out] scheduler Scheduler data
	*/
	static void
	unpack_node_state(const xmlNode state, pcmk_scheduler_t scheduler)
	{
	const char *id = NULL;
	const char *uname = NULL;
	pcmk_node_t *this_node = NULL;

	id = crm_element_value(state, PCMK_XA_ID);
	if (id == NULL) {
	pcmk__config_err("Ignoring invalid " PCMK__XE_NODE_STATE " entry without "
	PCMK_XA_ID);
	crm_log_xml_info(state, "missing-id");
	return;
	}

	uname = crm_element_value(state, PCMK_XA_UNAME);
	if (uname == NULL) {
	/* If a joining peer makes the cluster acquire the quorum from corosync
	* meanwhile it has not joined CPG membership of pacemaker-controld yet,
	* it's possible that the created PCMK__XE_NODE_STATE entry doesn't have
	* a PCMK_XA_UNAME yet. We should recognize the node as `pending` and
	* wait for it to join CPG.
	*/
	crm_trace("Handling " PCMK__XE_NODE_STATE " entry with id=\"%s\" "
	"without " PCMK_XA_UNAME,
	id);
	}

	this_node = pe_find_node_any(scheduler->nodes, id, uname);
	if (this_node == NULL) {
	crm_notice("Ignoring recorded state for removed node with name %s and "
	PCMK_XA_ID " %s", pcmk__s(uname, "unknown"), id);
	return;
	}

	if (pcmk__is_pacemaker_remote_node(this_node)) {
	int remote_fenced = 0;

	/* We can't determine the online status of Pacemaker Remote nodes until
	* after all resource history has been unpacked. In this first pass, we
	* do need to mark whether the node has been fenced, as this plays a
	* role during unpacking cluster node resource state.
	*/
	pcmk__scan_min_int(crm_element_value(state, PCMK__XA_NODE_FENCED),
	&remote_fenced, 0);
	if (remote_fenced) {
	pcmk__set_node_flags(this_node, pcmk__node_remote_fenced);
	} else {
	pcmk__clear_node_flags(this_node, pcmk__node_remote_fenced);
	}
	return;
	}

	unpack_transient_attributes(state, this_node, scheduler);

	/* Provisionally mark this cluster node as clean. We have at least seen it
	* in the current cluster's lifetime.
	*/
	this_node->details->unclean = FALSE;
	pcmk__set_node_flags(this_node, pcmk__node_seen);

	crm_trace("Determining online status of cluster node %s (id %s)",
	pcmk__node_name(this_node), id);
	determine_online_status(state, this_node, scheduler);

	if (!pcmk_is_set(scheduler->flags, pcmk_sched_quorate)
	&& this_node->details->online
	&& (scheduler->no_quorum_policy == pcmk_no_quorum_fence)) {
	/* Everything else should flow from this automatically
	* (at least until the scheduler becomes able to migrate off
	* healthy resources)
	*/
	pe_fence_node(scheduler, this_node, "cluster does not have quorum",
	FALSE);
	}
	}

	/*!
	* \internal
	* \brief Unpack nodes' resource history as much as possible
	*
	* Unpack as many nodes' resource history as possible in one pass through the
	* status. We need to process Pacemaker Remote nodes' connections/containers
	* before unpacking their history; the connection/container history will be
	* in another node's history, so it might take multiple passes to unpack
	* everything.
	*
	* \param[in] status CIB XML status section
	* \param[in] fence If true, treat any not-yet-unpacked nodes as unseen
	* \param[in,out] scheduler Scheduler data
	*
	* \return Standard Pacemaker return code (specifically pcmk_rc_ok if done,
	* or EAGAIN if more unpacking remains to be done)
	*/
	static int
	unpack_node_history(const xmlNode *status, bool fence,
	pcmk_scheduler_t *scheduler)
	{
	int rc = pcmk_rc_ok;

	// Loop through all PCMK__XE_NODE_STATE entries in CIB status
	for (const xmlNode *state = pcmk__xe_first_child(status,
	PCMK__XE_NODE_STATE, NULL,
	NULL);
	state != NULL; state = pcmk__xe_next_same(state)) {

	const char *id = pcmk__xe_id(state);
	const char *uname = crm_element_value(state, PCMK_XA_UNAME);
	pcmk_node_t *this_node = NULL;

	if ((id == NULL) \|\| (uname == NULL)) {
	// Warning already logged in first pass through status section
	crm_trace("Not unpacking resource history from malformed "
	PCMK__XE_NODE_STATE " without id and/or uname");
	continue;
	}

	this_node = pe_find_node_any(scheduler->nodes, id, uname);
	if (this_node == NULL) {
	// Warning already logged in first pass through status section
	crm_trace("Not unpacking resource history for node %s because "
	"no longer in configuration", id);
	continue;
	}

	if (pcmk_is_set(this_node->private->flags, pcmk__node_unpacked)) {
	crm_trace("Not unpacking resource history for node %s because "
	"already unpacked", id);
	continue;
	}

	if (fence) {
	// We're processing all remaining nodes

	} else if (pcmk__is_guest_or_bundle_node(this_node)) {
	/* We can unpack a guest node's history only after we've unpacked
	* other resource history to the point that we know that the node's
	* connection and containing resource are both up.
	*/
	const pcmk_resource_t *remote = this_node->private->remote;
	const pcmk_resource_t *launcher = remote->private->launcher;

	if ((remote->private->orig_role != pcmk_role_started)
	\|\| (launcher->private->orig_role != pcmk_role_started)) {
	crm_trace("Not unpacking resource history for guest node %s "
	"because launcher and connection are not known to "
	"be up", id);
	continue;
	}

	} else if (pcmk__is_remote_node(this_node)) {
	/* We can unpack a remote node's history only after we've unpacked
	* other resource history to the point that we know that the node's
	* connection is up, with the exception of when shutdown locks are
	* in use.
	*/
	pcmk_resource_t *rsc = this_node->private->remote;

	if ((rsc == NULL)
	\|\| (!pcmk_is_set(scheduler->flags, pcmk_sched_shutdown_lock)
	&& (rsc->private->orig_role != pcmk_role_started))) {
	crm_trace("Not unpacking resource history for remote node %s "
	"because connection is not known to be up", id);
	continue;
	}

	/* If fencing and shutdown locks are disabled and we're not processing
	* unseen nodes, then we don't want to unpack offline nodes until online
	* nodes have been unpacked. This allows us to number active clone
	* instances first.
	*/
	} else if (!pcmk_any_flags_set(scheduler->flags,
	pcmk_sched_fencing_enabled
	\|pcmk_sched_shutdown_lock)
	&& !this_node->details->online) {
	crm_trace("Not unpacking resource history for offline "
	"cluster node %s", id);
	continue;
	}

	if (pcmk__is_pacemaker_remote_node(this_node)) {
	determine_remote_online_status(scheduler, this_node);
	unpack_handle_remote_attrs(this_node, state, scheduler);
	}

	crm_trace("Unpacking resource history for %snode %s",
	(fence? "unseen " : ""), id);

	pcmk__set_node_flags(this_node, pcmk__node_unpacked);
	unpack_node_lrm(this_node, state, scheduler);

	rc = EAGAIN; // Other node histories might depend on this one
	}
	return rc;
	}

	/* remove nodes that are down, stopping */
	/* create positive rsc_to_node constraints between resources and the nodes they are running on */
	/* anything else? */
	gboolean
	unpack_status(xmlNode status, pcmk_scheduler_t scheduler)
	{
	xmlNode *state = NULL;

	crm_trace("Beginning unpack");

	if (scheduler->tickets == NULL) {
	scheduler->tickets = pcmk__strkey_table(free, destroy_ticket);
	}

	for (state = pcmk__xe_first_child(status, NULL, NULL, NULL); state != NULL;
	state = pcmk__xe_next(state)) {

	if (pcmk__xe_is(state, PCMK_XE_TICKETS)) {
	unpack_tickets_state((xmlNode *) state, scheduler);

	} else if (pcmk__xe_is(state, PCMK__XE_NODE_STATE)) {
	unpack_node_state(state, scheduler);
	}
	}

	while (unpack_node_history(status, FALSE, scheduler) == EAGAIN) {
	crm_trace("Another pass through node resource histories is needed");
	}

	// Now catch any nodes we didn't see
	unpack_node_history(status,
	pcmk_is_set(scheduler->flags,
	pcmk_sched_fencing_enabled),
	scheduler);

	/* Now that we know where resources are, we can schedule stops of containers
	* with failed bundle connections
	*/
	if (scheduler->stop_needed != NULL) {
	for (GList *item = scheduler->stop_needed; item; item = item->next) {
	pcmk_resource_t *container = item->data;
	pcmk_node_t *node = pcmk__current_node(container);

	if (node) {
	stop_action(container, node, FALSE);
	}
	}
	g_list_free(scheduler->stop_needed);
	scheduler->stop_needed = NULL;
	}

	/* Now that we know status of all Pacemaker Remote connections and nodes,
	* we can stop connections for node shutdowns, and check the online status
	* of remote/guest nodes that didn't have any node history to unpack.
	*/
	for (GList *gIter = scheduler->nodes; gIter != NULL; gIter = gIter->next) {
	pcmk_node_t *this_node = gIter->data;

	if (!pcmk__is_pacemaker_remote_node(this_node)) {
	continue;
	}
	if (this_node->details->shutdown
	&& (this_node->private->remote != NULL)) {
	pe__set_next_role(this_node->private->remote, pcmk_role_stopped,
	"remote shutdown");
	}
	if (!pcmk_is_set(this_node->private->flags, pcmk__node_unpacked)) {
	determine_remote_online_status(scheduler, this_node);
	}
	}

	return TRUE;
	}

	/*!
	* \internal
	* \brief Unpack node's time when it became a member at the cluster layer
	*
	* \param[in] node_state Node's \c PCMK__XE_NODE_STATE entry
	* \param[in,out] scheduler Scheduler data
	*
	* \return Epoch time when node became a cluster member
	* (or scheduler effective time for legacy entries) if a member,
	* 0 if not a member, or -1 if no valid information available
	*/
	static long long
	unpack_node_member(const xmlNode node_state, pcmk_scheduler_t scheduler)
	{
	const char *member_time = crm_element_value(node_state, PCMK__XA_IN_CCM);
	int member = 0;

	if (member_time == NULL) {
	return -1LL;

	} else if (crm_str_to_boolean(member_time, &member) == 1) {
	/* If in_ccm=0, we'll return 0 here. If in_ccm=1, either the entry was
	* recorded as a boolean for a DC < 2.1.7, or the node is pending
	* shutdown and has left the CPG, in which case it was set to 1 to avoid
	* fencing for PCMK_OPT_NODE_PENDING_TIMEOUT.
	*
	* We return the effective time for in_ccm=1 because what's important to
	* avoid fencing is that effective time minus this value is less than
	* the pending node timeout.
	*/
	return member? (long long) get_effective_time(scheduler) : 0LL;

	} else {
	long long when_member = 0LL;

	if ((pcmk__scan_ll(member_time, &when_member,
	0LL) != pcmk_rc_ok) \|\| (when_member < 0LL)) {
	crm_warn("Unrecognized value '%s' for " PCMK__XA_IN_CCM
	" in " PCMK__XE_NODE_STATE " entry", member_time);
	return -1LL;
	}
	return when_member;
	}
	}

	/*!
	* \internal
	* \brief Unpack node's time when it became online in process group
	*
	* \param[in] node_state Node's \c PCMK__XE_NODE_STATE entry
	*
	* \return Epoch time when node became online in process group (or 0 if not
	* online, or 1 for legacy online entries)
	*/
	static long long
	unpack_node_online(const xmlNode *node_state)
	{
	const char *peer_time = crm_element_value(node_state, PCMK_XA_CRMD);

	// @COMPAT Entries recorded for DCs < 2.1.7 have "online" or "offline"
	if (pcmk__str_eq(peer_time, PCMK_VALUE_OFFLINE,
	pcmk__str_casei\|pcmk__str_null_matches)) {
	return 0LL;

	} else if (pcmk__str_eq(peer_time, PCMK_VALUE_ONLINE, pcmk__str_casei)) {
	return 1LL;

	} else {
	long long when_online = 0LL;

	if ((pcmk__scan_ll(peer_time, &when_online, 0LL) != pcmk_rc_ok)
	\|\| (when_online < 0)) {
	crm_warn("Unrecognized value '%s' for " PCMK_XA_CRMD " in "
	PCMK__XE_NODE_STATE " entry, assuming offline", peer_time);
	return 0LL;
	}
	return when_online;
	}
	}

	/*!
	* \internal
	* \brief Unpack node attribute for user-requested fencing
	*
	* \param[in] node Node to check
	* \param[in] node_state Node's \c PCMK__XE_NODE_STATE entry in CIB status
	*
	* \return \c true if fencing has been requested for \p node, otherwise \c false
	*/
	static bool
	unpack_node_terminate(const pcmk_node_t node, const xmlNode node_state)
	{
	long long value = 0LL;
	int value_i = 0;
	const char *value_s = pcmk__node_attr(node, PCMK_NODE_ATTR_TERMINATE,
	NULL, pcmk__rsc_node_current);

	// Value may be boolean or an epoch time
	if (crm_str_to_boolean(value_s, &value_i) == 1) {
	return (value_i != 0);
	}
	if (pcmk__scan_ll(value_s, &value, 0LL) == pcmk_rc_ok) {
	return (value > 0);
	}
	crm_warn("Ignoring unrecognized value '%s' for " PCMK_NODE_ATTR_TERMINATE
	"node attribute for %s", value_s, pcmk__node_name(node));
	return false;
	}

	static gboolean
	determine_online_status_no_fencing(pcmk_scheduler_t *scheduler,
	const xmlNode *node_state,
	pcmk_node_t *this_node)
	{
	gboolean online = FALSE;
	const char *join = crm_element_value(node_state, PCMK__XA_JOIN);
	const char *exp_state = crm_element_value(node_state, PCMK_XA_EXPECTED);
	long long when_member = unpack_node_member(node_state, scheduler);
	long long when_online = unpack_node_online(node_state);

	if (when_member <= 0) {
	crm_trace("Node %s is %sdown", pcmk__node_name(this_node),
	((when_member < 0)? "presumed " : ""));

	} else if (when_online > 0) {
	if (pcmk__str_eq(join, CRMD_JOINSTATE_MEMBER, pcmk__str_casei)) {
	online = TRUE;
	} else {
	crm_debug("Node %s is not ready to run resources: %s",
	pcmk__node_name(this_node), join);
	}

	} else if (!pcmk_is_set(this_node->private->flags,
	pcmk__node_expected_up)) {
	crm_trace("Node %s controller is down: "
	"member@%lld online@%lld join=%s expected=%s",
	pcmk__node_name(this_node), when_member, when_online,
	pcmk__s(join, "<null>"), pcmk__s(exp_state, "<null>"));

	} else {
	/* mark it unclean */
	pe_fence_node(scheduler, this_node, "peer is unexpectedly down", FALSE);
	crm_info("Node %s member@%lld online@%lld join=%s expected=%s",
	pcmk__node_name(this_node), when_member, when_online,
	pcmk__s(join, "<null>"), pcmk__s(exp_state, "<null>"));
	}
	return online;
	}

	/*!
	* \internal
	* \brief Check whether a node has taken too long to join controller group
	*
	* \param[in,out] scheduler Scheduler data
	* \param[in] node Node to check
	* \param[in] when_member Epoch time when node became a cluster member
	* \param[in] when_online Epoch time when node joined controller group
	*
	* \return true if node has been pending (on the way up) longer than
	* \c PCMK_OPT_NODE_PENDING_TIMEOUT, otherwise false
	* \note This will also update the cluster's recheck time if appropriate.
	*/
	static inline bool
	pending_too_long(pcmk_scheduler_t scheduler, const pcmk_node_t node,
	long long when_member, long long when_online)
	{
	if ((scheduler->node_pending_timeout > 0)
	&& (when_member > 0) && (when_online <= 0)) {
	// There is a timeout on pending nodes, and node is pending

	time_t timeout = when_member + scheduler->node_pending_timeout;

	if (get_effective_time(node->private->scheduler) >= timeout) {
	return true; // Node has timed out
	}

	// Node is pending, but still has time
	pe__update_recheck_time(timeout, scheduler, "pending node timeout");
	}
	return false;
	}

	static bool
	determine_online_status_fencing(pcmk_scheduler_t *scheduler,
	const xmlNode *node_state,
	pcmk_node_t *this_node)
	{
	bool termination_requested = unpack_node_terminate(this_node, node_state);
	const char *join = crm_element_value(node_state, PCMK__XA_JOIN);
	const char *exp_state = crm_element_value(node_state, PCMK_XA_EXPECTED);
	long long when_member = unpack_node_member(node_state, scheduler);
	long long when_online = unpack_node_online(node_state);

	/*
	- PCMK__XA_JOIN ::= member\|down\|pending\|banned
	- PCMK_XA_EXPECTED ::= member\|down

	@COMPAT with entries recorded for DCs < 2.1.7
	- PCMK__XA_IN_CCM ::= true\|false
	- PCMK_XA_CRMD ::= online\|offline

	Since crm_feature_set 3.18.0 (pacemaker-2.1.7):
	- PCMK__XA_IN_CCM ::= <timestamp>\|0
	Since when node has been a cluster member. A value 0 of means the node is not
	a cluster member.

	- PCMK_XA_CRMD ::= <timestamp>\|0
	Since when peer has been online in CPG. A value 0 means the peer is offline
	in CPG.
	*/

	crm_trace("Node %s member@%lld online@%lld join=%s expected=%s%s",
	pcmk__node_name(this_node), when_member, when_online,
	pcmk__s(join, "<null>"), pcmk__s(exp_state, "<null>"),
	(termination_requested? " (termination requested)" : ""));

	if (this_node->details->shutdown) {
	crm_debug("%s is shutting down", pcmk__node_name(this_node));

	/* Slightly different criteria since we can't shut down a dead peer */
	return (when_online > 0);
	}

	if (when_member < 0) {
	pe_fence_node(scheduler, this_node,
	"peer has not been seen by the cluster", FALSE);
	return false;
	}

	if (pcmk__str_eq(join, CRMD_JOINSTATE_NACK, pcmk__str_none)) {
	pe_fence_node(scheduler, this_node,
	"peer failed Pacemaker membership criteria", FALSE);

	} else if (termination_requested) {
	if ((when_member <= 0) && (when_online <= 0)
	&& pcmk__str_eq(join, CRMD_JOINSTATE_DOWN, pcmk__str_none)) {
	crm_info("%s was fenced as requested", pcmk__node_name(this_node));
	return false;
	}
	pe_fence_node(scheduler, this_node, "fencing was requested", false);

	} else if (pcmk__str_eq(exp_state, CRMD_JOINSTATE_DOWN,
	pcmk__str_null_matches)) {

	if (pending_too_long(scheduler, this_node, when_member, when_online)) {
	pe_fence_node(scheduler, this_node,
	"peer pending timed out on joining the process group",
	FALSE);

	} else if ((when_member > 0) \|\| (when_online > 0)) {
	crm_info("- %s is not ready to run resources",
	pcmk__node_name(this_node));
	pcmk__set_node_flags(this_node, pcmk__node_standby);
	this_node->details->pending = TRUE;

	} else {
	crm_trace("%s is down or still coming up",
	pcmk__node_name(this_node));
	}

	} else if (when_member <= 0) {
	// Consider PCMK_OPT_PRIORITY_FENCING_DELAY for lost nodes
	pe_fence_node(scheduler, this_node,
	"peer is no longer part of the cluster", TRUE);

	} else if (when_online <= 0) {
	pe_fence_node(scheduler, this_node,
	"peer process is no longer available", FALSE);

	/* Everything is running at this point, now check join state */

	} else if (pcmk__str_eq(join, CRMD_JOINSTATE_MEMBER, pcmk__str_none)) {
	crm_info("%s is active", pcmk__node_name(this_node));

	} else if (pcmk__str_any_of(join, CRMD_JOINSTATE_PENDING,
	CRMD_JOINSTATE_DOWN, NULL)) {
	crm_info("%s is not ready to run resources",
	pcmk__node_name(this_node));
	pcmk__set_node_flags(this_node, pcmk__node_standby);
	this_node->details->pending = TRUE;

	} else {
	pe_fence_node(scheduler, this_node, "peer was in an unknown state",
	FALSE);
	}

	return (when_member > 0);
	}

	static void
	determine_remote_online_status(pcmk_scheduler_t *scheduler,
	pcmk_node_t *this_node)
	{
	pcmk_resource_t *rsc = this_node->private->remote;
	pcmk_resource_t *launcher = NULL;
	pcmk_node_t *host = NULL;
	const char *node_type = "Remote";

	if (rsc == NULL) {
	/* This is a leftover node state entry for a former Pacemaker Remote
	* node whose connection resource was removed. Consider it offline.
	*/
	crm_trace("Pacemaker Remote node %s is considered OFFLINE because "
	"its connection resource has been removed from the CIB",
	this_node->private->id);
	this_node->details->online = FALSE;
	return;
	}

	launcher = rsc->private->launcher;
	if (launcher != NULL) {
	node_type = "Guest";
	if (pcmk__list_of_1(rsc->private->active_nodes)) {
	host = rsc->private->active_nodes->data;
	}
	}

	/* If the resource is currently started, mark it online. */
	if (rsc->private->orig_role == pcmk_role_started) {
	this_node->details->online = TRUE;
	}

	/* consider this node shutting down if transitioning start->stop */
	if ((rsc->private->orig_role == pcmk_role_started)
	&& (rsc->private->next_role == pcmk_role_stopped)) {

	crm_trace("%s node %s shutting down because connection resource is stopping",
	node_type, this_node->private->id);
	this_node->details->shutdown = TRUE;
	}

	/* Now check all the failure conditions. */
	if ((launcher != NULL) && pcmk_is_set(launcher->flags, pcmk__rsc_failed)) {
	crm_trace("Guest node %s UNCLEAN because guest resource failed",
	this_node->private->id);
	this_node->details->online = FALSE;
	pcmk__set_node_flags(this_node, pcmk__node_remote_reset);

	} else if (pcmk_is_set(rsc->flags, pcmk__rsc_failed)) {
	crm_trace("%s node %s OFFLINE because connection resource failed",
	node_type, this_node->private->id);
	this_node->details->online = FALSE;

	} else if ((rsc->private->orig_role == pcmk_role_stopped)
	\|\| ((launcher != NULL)
	&& (launcher->private->orig_role == pcmk_role_stopped))) {

	crm_trace("%s node %s OFFLINE because its resource is stopped",
	node_type, this_node->private->id);
	this_node->details->online = FALSE;
	pcmk__clear_node_flags(this_node, pcmk__node_remote_reset);

	} else if (host && (host->details->online == FALSE)
	&& host->details->unclean) {
	crm_trace("Guest node %s UNCLEAN because host is unclean",
	this_node->private->id);
	this_node->details->online = FALSE;
	pcmk__set_node_flags(this_node, pcmk__node_remote_reset);

	} else {
	crm_trace("%s node %s is %s",
	node_type, this_node->private->id,
	this_node->details->online? "ONLINE" : "OFFLINE");
	}
	}

	static void
	determine_online_status(const xmlNode node_state, pcmk_node_t this_node,
	pcmk_scheduler_t *scheduler)
	{
	gboolean online = FALSE;
	const char *exp_state = crm_element_value(node_state, PCMK_XA_EXPECTED);

	CRM_CHECK(this_node != NULL, return);

	this_node->details->shutdown = FALSE;

	if (pe__shutdown_requested(this_node)) {
	this_node->details->shutdown = TRUE;

	} else if (pcmk__str_eq(exp_state, CRMD_JOINSTATE_MEMBER, pcmk__str_casei)) {
	pcmk__set_node_flags(this_node, pcmk__node_expected_up);
	}

	if (this_node->private->variant == pcmk__node_variant_ping) {
	this_node->details->unclean = FALSE;
	online = FALSE; /* As far as resource management is concerned,
	* the node is safely offline.
	* Anyone caught abusing this logic will be shot
	*/

	} else if (!pcmk_is_set(scheduler->flags, pcmk_sched_fencing_enabled)) {
	online = determine_online_status_no_fencing(scheduler, node_state,
	this_node);

	} else {
	online = determine_online_status_fencing(scheduler, node_state,
	this_node);
	}

	if (online) {
	this_node->details->online = TRUE;

	} else {
	/* remove node from contention */
	this_node->assign->score = -PCMK_SCORE_INFINITY;
	}

	if (online && this_node->details->shutdown) {
	/* don't run resources here */
	this_node->assign->score = -PCMK_SCORE_INFINITY;
	}

	if (this_node->private->variant == pcmk__node_variant_ping) {
	crm_info("%s is not a Pacemaker node", pcmk__node_name(this_node));

	} else if (this_node->details->unclean) {
	pcmk__sched_warn("%s is unclean", pcmk__node_name(this_node));

	} else if (!this_node->details->online) {
	crm_trace("%s is offline", pcmk__node_name(this_node));

	} else if (this_node->details->shutdown) {
	crm_info("%s is shutting down", pcmk__node_name(this_node));

	} else if (this_node->details->pending) {
	crm_info("%s is pending", pcmk__node_name(this_node));

	} else if (pcmk_is_set(this_node->private->flags, pcmk__node_standby)) {
	crm_info("%s is in standby", pcmk__node_name(this_node));

	} else if (this_node->details->maintenance) {
	crm_info("%s is in maintenance", pcmk__node_name(this_node));

	} else {
	crm_info("%s is online", pcmk__node_name(this_node));
	}
	}

	/*!
	* \internal
	* \brief Find the end of a resource's name, excluding any clone suffix
	*
	* \param[in] id Resource ID to check
	*
	* \return Pointer to last character of resource's base name
	*/
	const char *
	pe_base_name_end(const char *id)
	{
	if (!pcmk__str_empty(id)) {
	const char *end = id + strlen(id) - 1;

	for (const char *s = end; s > id; --s) {
	switch (*s) {
	case '0':
	case '1':
	case '2':
	case '3':
	case '4':
	case '5':
	case '6':
	case '7':
	case '8':
	case '9':
	break;
	case ':':
	return (s == end)? s : (s - 1);
	default:
	return end;
	}
	}
	return end;
	}
	return NULL;
	}

	/*!
	* \internal
	* \brief Get a resource name excluding any clone suffix
	*
	* \param[in] last_rsc_id Resource ID to check
	*
	* \return Pointer to newly allocated string with resource's base name
	* \note It is the caller's responsibility to free() the result.
	* This asserts on error, so callers can assume result is not NULL.
	*/
	char *
	clone_strip(const char *last_rsc_id)
	{
	const char *end = pe_base_name_end(last_rsc_id);
	char *basename = NULL;

	CRM_ASSERT(end);
	basename = strndup(last_rsc_id, end - last_rsc_id + 1);
	CRM_ASSERT(basename);
	return basename;
	}

	/*!
	* \internal
	* \brief Get the name of the first instance of a cloned resource
	*
	* \param[in] last_rsc_id Resource ID to check
	*
	* \return Pointer to newly allocated string with resource's base name plus :0
	* \note It is the caller's responsibility to free() the result.
	* This asserts on error, so callers can assume result is not NULL.
	*/
	char *
	clone_zero(const char *last_rsc_id)
	{
	const char *end = pe_base_name_end(last_rsc_id);
	size_t base_name_len = end - last_rsc_id + 1;
	char *zero = NULL;

	CRM_ASSERT(end);
	zero = pcmk__assert_alloc(base_name_len + 3, sizeof(char));
	memcpy(zero, last_rsc_id, base_name_len);
	zero[base_name_len] = ':';
	zero[base_name_len + 1] = '0';
	return zero;
	}

	static pcmk_resource_t *
	create_fake_resource(const char rsc_id, const xmlNode rsc_entry,
	pcmk_scheduler_t *scheduler)
	{
	pcmk_resource_t *rsc = NULL;
	xmlNode *xml_rsc = pcmk__xe_create(NULL, PCMK_XE_PRIMITIVE);

	pcmk__xe_copy_attrs(xml_rsc, rsc_entry, pcmk__xaf_none);
	crm_xml_add(xml_rsc, PCMK_XA_ID, rsc_id);
	crm_log_xml_debug(xml_rsc, "Orphan resource");

	if (pe__unpack_resource(xml_rsc, &rsc, NULL, scheduler) != pcmk_rc_ok) {
	return NULL;
	}

	if (xml_contains_remote_node(xml_rsc)) {
	pcmk_node_t *node;

	crm_debug("Detected orphaned remote node %s", rsc_id);
	node = pcmk_find_node(scheduler, rsc_id);
	if (node == NULL) {
	node = pe_create_node(rsc_id, rsc_id, PCMK_VALUE_REMOTE, NULL,
	scheduler);
	}
	link_rsc2remotenode(scheduler, rsc);

	if (node) {
	crm_trace("Setting node %s as shutting down due to orphaned connection resource", rsc_id);
	node->details->shutdown = TRUE;
	}
	}

	if (crm_element_value(rsc_entry, PCMK__META_CONTAINER)) {
	// This removed resource needs to be mapped to a launcher
	crm_trace("Launched resource %s was removed from the configuration",
	rsc_id);
	pcmk__set_rsc_flags(rsc, pcmk__rsc_removed_launched);
	}
	pcmk__set_rsc_flags(rsc, pcmk__rsc_removed);
	scheduler->resources = g_list_append(scheduler->resources, rsc);
	return rsc;
	}

	/*!
	* \internal
	* \brief Create orphan instance for anonymous clone resource history
	*
	* \param[in,out] parent Clone resource that orphan will be added to
	* \param[in] rsc_id Orphan's resource ID
	* \param[in] node Where orphan is active (for logging only)
	* \param[in,out] scheduler Scheduler data
	*
	* \return Newly added orphaned instance of \p parent
	*/
	static pcmk_resource_t *
	create_anonymous_orphan(pcmk_resource_t parent, const char rsc_id,
	const pcmk_node_t node, pcmk_scheduler_t scheduler)
	{
	pcmk_resource_t *top = pe__create_clone_child(parent, scheduler);
	pcmk_resource_t *orphan = NULL;

	// find_rsc() because we might be a cloned group
	orphan = top->private->fns->find_rsc(top, rsc_id, NULL,
	pcmk_rsc_match_clone_only);

	pcmk__rsc_debug(parent, "Created orphan %s for %s: %s on %s",
	top->id, parent->id, rsc_id, pcmk__node_name(node));
	return orphan;
	}

	/*!
	* \internal
	* \brief Check a node for an instance of an anonymous clone
	*
	* Return a child instance of the specified anonymous clone, in order of
	* preference: (1) the instance running on the specified node, if any;
	* (2) an inactive instance (i.e. within the total of \c PCMK_META_CLONE_MAX
	* instances); (3) a newly created orphan (that is, \c PCMK_META_CLONE_MAX
	* instances are already active).
	*
	* \param[in,out] scheduler Scheduler data
	* \param[in] node Node on which to check for instance
	* \param[in,out] parent Clone to check
	* \param[in] rsc_id Name of cloned resource in history (no instance)
	*/
	static pcmk_resource_t *
	find_anonymous_clone(pcmk_scheduler_t scheduler, const pcmk_node_t node,
	pcmk_resource_t parent, const char rsc_id)
	{
	GList *rIter = NULL;
	pcmk_resource_t *rsc = NULL;
	pcmk_resource_t *inactive_instance = NULL;
	gboolean skip_inactive = FALSE;

	CRM_ASSERT(pcmk__is_anonymous_clone(parent));

	// Check for active (or partially active, for cloned groups) instance
	pcmk__rsc_trace(parent, "Looking for %s on %s in %s",
	rsc_id, pcmk__node_name(node), parent->id);

	for (rIter = parent->private->children;
	(rIter != NULL) && (rsc == NULL); rIter = rIter->next) {

	GList *locations = NULL;
	pcmk_resource_t *child = rIter->data;

	/* Check whether this instance is already known to be active or pending
	* anywhere, at this stage of unpacking. Because this function is called
	* for a resource before the resource's individual operation history
	* entries are unpacked, locations will generally not contain the
	* desired node.
	*
	* However, there are three exceptions:
	* (1) when child is a cloned group and we have already unpacked the
	* history of another member of the group on the same node;
	* (2) when we've already unpacked the history of another numbered
	* instance on the same node (which can happen if
	* PCMK_META_GLOBALLY_UNIQUE was flipped from true to false); and
	* (3) when we re-run calculations on the same scheduler data as part of
	* a simulation.
	*/
	child->private->fns->location(child, &locations, 2);
	if (locations) {
	/* We should never associate the same numbered anonymous clone
	* instance with multiple nodes, and clone instances can't migrate,
	* so there must be only one location, regardless of history.
	*/
	CRM_LOG_ASSERT(locations->next == NULL);

	if (pcmk__same_node((pcmk_node_t *) locations->data, node)) {
	/* This child instance is active on the requested node, so check
	* for a corresponding configured resource. We use find_rsc()
	* instead of child because child may be a cloned group, and we
	* need the particular member corresponding to rsc_id.
	*
	* If the history entry is orphaned, rsc will be NULL.
	*/
	rsc = parent->private->fns->find_rsc(child, rsc_id, NULL,
	pcmk_rsc_match_clone_only);
	if (rsc) {
	/* If there are multiple instance history entries for an
	* anonymous clone in a single node's history (which can
	* happen if PCMK_META_GLOBALLY_UNIQUE is switched from true
	* to false), we want to consider the instances beyond the
	* first as orphans, even if there are inactive instance
	* numbers available.
	*/
	if (rsc->private->active_nodes != NULL) {
	crm_notice("Active (now-)anonymous clone %s has "
	"multiple (orphan) instance histories on %s",
	parent->id, pcmk__node_name(node));
	skip_inactive = TRUE;
	rsc = NULL;
	} else {
	pcmk__rsc_trace(parent, "Resource %s, active", rsc->id);
	}
	}
	}
	g_list_free(locations);

	} else {
	pcmk__rsc_trace(parent, "Resource %s, skip inactive", child->id);
	if (!skip_inactive && !inactive_instance
	&& !pcmk_is_set(child->flags, pcmk__rsc_blocked)) {
	// Remember one inactive instance in case we don't find active
	inactive_instance =
	parent->private->fns->find_rsc(child, rsc_id, NULL,
	pcmk_rsc_match_clone_only);

	/* ... but don't use it if it was already associated with a
	* pending action on another node
	*/
	if (inactive_instance != NULL) {
	const pcmk_node_t *pending_node = NULL;

	pending_node = inactive_instance->private->pending_node;
	if ((pending_node != NULL)
	&& !pcmk__same_node(pending_node, node)) {
	inactive_instance = NULL;
	}
	}
	}
	}
	}

	if ((rsc == NULL) && !skip_inactive && (inactive_instance != NULL)) {
	pcmk__rsc_trace(parent, "Resource %s, empty slot",
	inactive_instance->id);
	rsc = inactive_instance;
	}

	/* If the resource has PCMK_META_REQUIRES set to PCMK_VALUE_QUORUM or
	* PCMK_VALUE_NOTHING, and we don't have a clone instance for every node, we
	* don't want to consume a valid instance number for unclean nodes. Such
	* instances may appear to be active according to the history, but should be
	* considered inactive, so we can start an instance elsewhere. Treat such
	* instances as orphans.
	*
	* An exception is instances running on guest nodes -- since guest node
	* "fencing" is actually just a resource stop, requires shouldn't apply.
	*
	* @TODO Ideally, we'd use an inactive instance number if it is not needed
	* for any clean instances. However, we don't know that at this point.
	*/
	if ((rsc != NULL) && !pcmk_is_set(rsc->flags, pcmk__rsc_needs_fencing)
	&& (!node->details->online \|\| node->details->unclean)
	&& !pcmk__is_guest_or_bundle_node(node)
	&& !pe__is_universal_clone(parent, scheduler)) {

	rsc = NULL;
	}

	if (rsc == NULL) {
	rsc = create_anonymous_orphan(parent, rsc_id, node, scheduler);
	pcmk__rsc_trace(parent, "Resource %s, orphan", rsc->id);
	}
	return rsc;
	}

	static pcmk_resource_t *
	unpack_find_resource(pcmk_scheduler_t scheduler, const pcmk_node_t node,
	const char *rsc_id)
	{
	pcmk_resource_t *rsc = NULL;
	pcmk_resource_t *parent = NULL;

	crm_trace("looking for %s", rsc_id);
	rsc = pe_find_resource(scheduler->resources, rsc_id);

	if (rsc == NULL) {
	/* If we didn't find the resource by its name in the operation history,
	* check it again as a clone instance. Even when PCMK_META_CLONE_MAX=0,
	* we create a single :0 orphan to match against here.
	*/
	char *clone0_id = clone_zero(rsc_id);
	pcmk_resource_t *clone0 = pe_find_resource(scheduler->resources,
	clone0_id);

	if (clone0 && !pcmk_is_set(clone0->flags, pcmk__rsc_unique)) {
	rsc = clone0;
	parent = uber_parent(clone0);
	crm_trace("%s found as %s (%s)", rsc_id, clone0_id, parent->id);
	} else {
	crm_trace("%s is not known as %s either (orphan)",
	rsc_id, clone0_id);
	}
	free(clone0_id);

	} else if (rsc->private->variant > pcmk__rsc_variant_primitive) {
	crm_trace("Resource history for %s is orphaned "
	"because it is no longer primitive", rsc_id);
	return NULL;

	} else {
	parent = uber_parent(rsc);
	}

	if (pcmk__is_anonymous_clone(parent)) {

	if (pcmk__is_bundled(parent)) {
	rsc = pe__find_bundle_replica(parent->private->parent, node);
	} else {
	char *base = clone_strip(rsc_id);

	rsc = find_anonymous_clone(scheduler, node, parent, base);
	free(base);
	CRM_ASSERT(rsc != NULL);
	}
	}

	if (rsc && !pcmk__str_eq(rsc_id, rsc->id, pcmk__str_none)
	&& !pcmk__str_eq(rsc_id, rsc->private->history_id, pcmk__str_none)) {

	pcmk__str_update(&(rsc->private->history_id), rsc_id);
	pcmk__rsc_debug(rsc, "Internally renamed %s on %s to %s%s",
	rsc_id, pcmk__node_name(node), rsc->id,
	pcmk_is_set(rsc->flags, pcmk__rsc_removed)? " (ORPHAN)" : "");
	}
	return rsc;
	}

	static pcmk_resource_t *
	process_orphan_resource(const xmlNode rsc_entry, const pcmk_node_t node,
	pcmk_scheduler_t *scheduler)
	{
	pcmk_resource_t *rsc = NULL;
	const char *rsc_id = crm_element_value(rsc_entry, PCMK_XA_ID);

	crm_debug("Detected orphan resource %s on %s",
	rsc_id, pcmk__node_name(node));
	rsc = create_fake_resource(rsc_id, rsc_entry, scheduler);
	if (rsc == NULL) {
	return NULL;
	}

	if (!pcmk_is_set(scheduler->flags, pcmk_sched_stop_removed_resources)) {
	pcmk__clear_rsc_flags(rsc, pcmk__rsc_managed);

	} else {
	CRM_CHECK(rsc != NULL, return NULL);
	pcmk__rsc_trace(rsc, "Added orphan %s", rsc->id);
	resource_location(rsc, NULL, -PCMK_SCORE_INFINITY,
	"__orphan_do_not_run__", scheduler);
	}
	return rsc;
	}

	static void
	process_rsc_state(pcmk_resource_t rsc, pcmk_node_t node,
	enum pcmk__on_fail on_fail)
	{
	pcmk_node_t *tmpnode = NULL;
	char *reason = NULL;
	enum pcmk__on_fail save_on_fail = pcmk__on_fail_ignore;
	pcmk_scheduler_t *scheduler = NULL;
	bool known_active = false;

	CRM_ASSERT(rsc);
	scheduler = rsc->private->scheduler;
	known_active = (rsc->private->orig_role > pcmk_role_stopped);
	pcmk__rsc_trace(rsc, "Resource %s is %s on %s: on_fail=%s",
	rsc->id, pcmk_role_text(rsc->private->orig_role),
	pcmk__node_name(node), pcmk__on_fail_text(on_fail));

	/* process current state */
	if (rsc->private->orig_role != pcmk_role_unknown) {
	pcmk_resource_t *iter = rsc;

	while (iter) {
	if (g_hash_table_lookup(iter->private->probed_nodes,
	node->private->id) == NULL) {
	pcmk_node_t *n = pe__copy_node(node);

	pcmk__rsc_trace(rsc, "%s (%s in history) known on %s",
	rsc->id,
	pcmk__s(rsc->private->history_id, "the same"),
	pcmk__node_name(n));
	g_hash_table_insert(iter->private->probed_nodes,
	(gpointer) n->private->id, n);
	}
	if (pcmk_is_set(iter->flags, pcmk__rsc_unique)) {
	break;
	}
	iter = iter->private->parent;
	}
	}

	/* If a managed resource is believed to be running, but node is down ... */
	if (known_active && !node->details->online && !node->details->maintenance
	&& pcmk_is_set(rsc->flags, pcmk__rsc_managed)) {

	gboolean should_fence = FALSE;

	/* If this is a guest node, fence it (regardless of whether fencing is
	* enabled, because guest node fencing is done by recovery of the
	* container resource rather than by the fencer). Mark the resource
	* we're processing as failed. When the guest comes back up, its
	* operation history in the CIB will be cleared, freeing the affected
	* resource to run again once we are sure we know its state.
	*/
	if (pcmk__is_guest_or_bundle_node(node)) {
	pcmk__set_rsc_flags(rsc, pcmk__rsc_failed\|pcmk__rsc_stop_if_failed);
	should_fence = TRUE;

	} else if (pcmk_is_set(scheduler->flags, pcmk_sched_fencing_enabled)) {
	if (pcmk__is_remote_node(node)
	&& (node->private->remote != NULL)
	&& !pcmk_is_set(node->private->remote->flags,
	pcmk__rsc_failed)) {

	/* Setting unseen means that fencing of the remote node will
	* occur only if the connection resource is not going to start
	* somewhere. This allows connection resources on a failed
	* cluster node to move to another node without requiring the
	* remote nodes to be fenced as well.
	*/
	pcmk__clear_node_flags(node, pcmk__node_seen);
	reason = crm_strdup_printf("%s is active there (fencing will be"
	" revoked if remote connection can "
	"be re-established elsewhere)",
	rsc->id);
	}
	should_fence = TRUE;
	}

	if (should_fence) {
	if (reason == NULL) {
	reason = crm_strdup_printf("%s is thought to be active there", rsc->id);
	}
	pe_fence_node(scheduler, node, reason, FALSE);
	}
	free(reason);
	}

	/* In order to calculate priority_fencing_delay correctly, save the failure information and pass it to native_add_running(). */
	save_on_fail = on_fail;

	if (node->details->unclean) {
	/* No extra processing needed
	* Also allows resources to be started again after a node is shot
	*/
	on_fail = pcmk__on_fail_ignore;
	}

	switch (on_fail) {
	case pcmk__on_fail_ignore:
	/* nothing to do */
	break;

	case pcmk__on_fail_demote:
	pcmk__set_rsc_flags(rsc, pcmk__rsc_failed);
	demote_action(rsc, node, FALSE);
	break;

	case pcmk__on_fail_fence_node:
	/* treat it as if it is still running
	* but also mark the node as unclean
	*/
	reason = crm_strdup_printf("%s failed there", rsc->id);
	pe_fence_node(scheduler, node, reason, FALSE);
	free(reason);
	break;

	case pcmk__on_fail_standby_node:
	pcmk__set_node_flags(node,
	pcmk__node_standby\|pcmk__node_fail_standby);
	break;

	case pcmk__on_fail_block:
	/* is_managed == FALSE will prevent any
	* actions being sent for the resource
	*/
	pcmk__clear_rsc_flags(rsc, pcmk__rsc_managed);
	pcmk__set_rsc_flags(rsc, pcmk__rsc_blocked);
	break;

	case pcmk__on_fail_ban:
	/* make sure it comes up somewhere else
	* or not at all
	*/
	resource_location(rsc, node, -PCMK_SCORE_INFINITY,
	"__action_migration_auto__", scheduler);
	break;

	case pcmk__on_fail_stop:
	pe__set_next_role(rsc, pcmk_role_stopped,
	PCMK_META_ON_FAIL "=" PCMK_VALUE_STOP);
	break;

	case pcmk__on_fail_restart:
	if (known_active) {
	pcmk__set_rsc_flags(rsc,
	pcmk__rsc_failed\|pcmk__rsc_stop_if_failed);
	stop_action(rsc, node, FALSE);
	}
	break;

	case pcmk__on_fail_restart_container:
	pcmk__set_rsc_flags(rsc, pcmk__rsc_failed\|pcmk__rsc_stop_if_failed);
	if ((rsc->private->launcher != NULL) && pcmk__is_bundled(rsc)) {
	/* A bundle's remote connection can run on a different node than
	* the bundle's container. We don't necessarily know where the
	* container is running yet, so remember it and add a stop
	* action for it later.
	*/
	scheduler->stop_needed = g_list_prepend(scheduler->stop_needed,
	rsc->private->launcher);
	} else if (rsc->private->launcher != NULL) {
	stop_action(rsc->private->launcher, node, FALSE);
	} else if (known_active) {
	stop_action(rsc, node, FALSE);
	}
	break;

	case pcmk__on_fail_reset_remote:
	pcmk__set_rsc_flags(rsc, pcmk__rsc_failed\|pcmk__rsc_stop_if_failed);
	if (pcmk_is_set(scheduler->flags, pcmk_sched_fencing_enabled)) {
	tmpnode = NULL;
	if (pcmk_is_set(rsc->flags, pcmk__rsc_is_remote_connection)) {
	tmpnode = pcmk_find_node(scheduler, rsc->id);
	}
	if (pcmk__is_remote_node(tmpnode)
	&& !pcmk_is_set(tmpnode->private->flags,
	pcmk__node_remote_fenced)) {
	/* The remote connection resource failed in a way that
	* should result in fencing the remote node.
	*/
	pe_fence_node(scheduler, tmpnode,
	"remote connection is unrecoverable", FALSE);
	}
	}

	/* require the stop action regardless if fencing is occurring or not. */
	if (known_active) {
	stop_action(rsc, node, FALSE);
	}

	/* if reconnect delay is in use, prevent the connection from exiting the
	* "STOPPED" role until the failure is cleared by the delay timeout. */
	if (rsc->private->remote_reconnect_ms > 0U) {
	pe__set_next_role(rsc, pcmk_role_stopped, "remote reset");
	}
	break;
	}

	/* Ensure a remote connection failure forces an unclean Pacemaker Remote
	* node to be fenced. By marking the node as seen, the failure will result
	* in a fencing operation regardless if we're going to attempt to reconnect
	* in this transition.
	*/
	if (pcmk_all_flags_set(rsc->flags,
	pcmk__rsc_failed\|pcmk__rsc_is_remote_connection)) {
	tmpnode = pcmk_find_node(scheduler, rsc->id);
	if (tmpnode && tmpnode->details->unclean) {
	pcmk__set_node_flags(tmpnode, pcmk__node_seen);
	}
	}

	if (known_active) {
	if (pcmk_is_set(rsc->flags, pcmk__rsc_removed)) {
	if (pcmk_is_set(rsc->flags, pcmk__rsc_managed)) {
	crm_notice("Removed resource %s is active on %s and will be "
	"stopped when possible",
	rsc->id, pcmk__node_name(node));
	} else {
	crm_notice("Removed resource %s must be stopped manually on %s "
	"because " PCMK_OPT_STOP_ORPHAN_RESOURCES
	" is set to false", rsc->id, pcmk__node_name(node));
	}
	}

	native_add_running(rsc, node, scheduler,
	(save_on_fail != pcmk__on_fail_ignore));
	switch (on_fail) {
	case pcmk__on_fail_ignore:
	break;
	case pcmk__on_fail_demote:
	case pcmk__on_fail_block:
	pcmk__set_rsc_flags(rsc, pcmk__rsc_failed);
	break;
	default:
	pcmk__set_rsc_flags(rsc,
	pcmk__rsc_failed\|pcmk__rsc_stop_if_failed);
	break;
	}

	} else if ((rsc->private->history_id != NULL)
	&& (strchr(rsc->private->history_id, ':') != NULL)) {
	/* Only do this for older status sections that included instance numbers
	* Otherwise stopped instances will appear as orphans
	*/
	pcmk__rsc_trace(rsc, "Clearing history ID %s for %s (stopped)",
	rsc->private->history_id, rsc->id);
	free(rsc->private->history_id);
	rsc->private->history_id = NULL;

	} else {
	GList *possible_matches = pe__resource_actions(rsc, node,
	PCMK_ACTION_STOP, FALSE);
	GList *gIter = possible_matches;

	for (; gIter != NULL; gIter = gIter->next) {
	pcmk_action_t stop = (pcmk_action_t ) gIter->data;

	pcmk__set_action_flags(stop, pcmk__action_optional);
	}

	g_list_free(possible_matches);
	}

	/* A successful stop after migrate_to on the migration source doesn't make
	* the partially migrated resource stopped on the migration target.
	*/
	if ((rsc->private->orig_role == pcmk_role_stopped)
	&& (rsc->private->active_nodes != NULL)
	&& (rsc->private->partial_migration_target != NULL)
	&& pcmk__same_node(rsc->private->partial_migration_source, node)) {

	rsc->private->orig_role = pcmk_role_started;
	}
	}

	/* create active recurring operations as optional */
	static void
	process_recurring(pcmk_node_t node, pcmk_resource_t rsc,
	int start_index, int stop_index,
	GList sorted_op_list, pcmk_scheduler_t scheduler)
	{
	int counter = -1;
	const char *task = NULL;
	const char *status = NULL;
	GList *gIter = sorted_op_list;

	CRM_ASSERT(rsc);
	pcmk__rsc_trace(rsc, "%s: Start index %d, stop index = %d",
	rsc->id, start_index, stop_index);

	for (; gIter != NULL; gIter = gIter->next) {
	xmlNode rsc_op = (xmlNode ) gIter->data;

	guint interval_ms = 0;
	char *key = NULL;
	const char *id = pcmk__xe_id(rsc_op);

	counter++;

	if (node->details->online == FALSE) {
	pcmk__rsc_trace(rsc, "Skipping %s on %s: node is offline",
	rsc->id, pcmk__node_name(node));
	break;

	/* Need to check if there's a monitor for role="Stopped" */
	} else if (start_index < stop_index && counter <= stop_index) {
	pcmk__rsc_trace(rsc, "Skipping %s on %s: resource is not active",
	id, pcmk__node_name(node));
	continue;

	} else if (counter < start_index) {
	pcmk__rsc_trace(rsc, "Skipping %s on %s: old %d",
	id, pcmk__node_name(node), counter);
	continue;
	}

	crm_element_value_ms(rsc_op, PCMK_META_INTERVAL, &interval_ms);
	if (interval_ms == 0) {
	pcmk__rsc_trace(rsc, "Skipping %s on %s: non-recurring",
	id, pcmk__node_name(node));
	continue;
	}

	status = crm_element_value(rsc_op, PCMK__XA_OP_STATUS);
	if (pcmk__str_eq(status, "-1", pcmk__str_casei)) {
	pcmk__rsc_trace(rsc, "Skipping %s on %s: status",
	id, pcmk__node_name(node));
	continue;
	}
	task = crm_element_value(rsc_op, PCMK_XA_OPERATION);
	/* create the action */
	key = pcmk__op_key(rsc->id, task, interval_ms);
	pcmk__rsc_trace(rsc, "Creating %s on %s", key, pcmk__node_name(node));
	custom_action(rsc, key, task, node, TRUE, scheduler);
	}
	}

	void
	calculate_active_ops(const GList sorted_op_list, int start_index,
	int *stop_index)
	{
	int counter = -1;
	int implied_monitor_start = -1;
	int implied_clone_start = -1;
	const char *task = NULL;
	const char *status = NULL;

	*stop_index = -1;
	*start_index = -1;

	for (const GList *iter = sorted_op_list; iter != NULL; iter = iter->next) {
	const xmlNode rsc_op = (const xmlNode ) iter->data;

	counter++;

	task = crm_element_value(rsc_op, PCMK_XA_OPERATION);
	status = crm_element_value(rsc_op, PCMK__XA_OP_STATUS);

	if (pcmk__str_eq(task, PCMK_ACTION_STOP, pcmk__str_casei)
	&& pcmk__str_eq(status, "0", pcmk__str_casei)) {
	*stop_index = counter;

	} else if (pcmk__strcase_any_of(task, PCMK_ACTION_START,
	PCMK_ACTION_MIGRATE_FROM, NULL)) {
	*start_index = counter;

	} else if ((implied_monitor_start <= *stop_index)
	&& pcmk__str_eq(task, PCMK_ACTION_MONITOR,
	pcmk__str_casei)) {
	const char *rc = crm_element_value(rsc_op, PCMK__XA_RC_CODE);

	if (pcmk__strcase_any_of(rc, "0", "8", NULL)) {
	implied_monitor_start = counter;
	}
	} else if (pcmk__strcase_any_of(task, PCMK_ACTION_PROMOTE,
	PCMK_ACTION_DEMOTE, NULL)) {
	implied_clone_start = counter;
	}
	}

	if (*start_index == -1) {
	if (implied_clone_start != -1) {
	*start_index = implied_clone_start;
	} else if (implied_monitor_start != -1) {
	*start_index = implied_monitor_start;
	}
	}
	}

	// If resource history entry has shutdown lock, remember lock node and time
	static void
	unpack_shutdown_lock(const xmlNode rsc_entry, pcmk_resource_t rsc,
	const pcmk_node_t node, pcmk_scheduler_t scheduler)
	{
	time_t lock_time = 0; // When lock started (i.e. node shutdown time)

	if ((crm_element_value_epoch(rsc_entry, PCMK_OPT_SHUTDOWN_LOCK,
	&lock_time) == pcmk_ok) && (lock_time != 0)) {

	if ((scheduler->shutdown_lock > 0)
	&& (get_effective_time(scheduler)
	> (lock_time + scheduler->shutdown_lock))) {
	pcmk__rsc_info(rsc, "Shutdown lock for %s on %s expired",
	rsc->id, pcmk__node_name(node));
	pe__clear_resource_history(rsc, node);
	} else {
	rsc->private->lock_node = node;
	rsc->private->lock_time = lock_time;
	}
	}
	}

	/*!
	* \internal
	* \brief Unpack one \c PCMK__XE_LRM_RESOURCE entry from a node's CIB status
	*
	* \param[in,out] node Node whose status is being unpacked
	* \param[in] rsc_entry \c PCMK__XE_LRM_RESOURCE XML being unpacked
	* \param[in,out] scheduler Scheduler data
	*
	* \return Resource corresponding to the entry, or NULL if no operation history
	*/
	static pcmk_resource_t *
	unpack_lrm_resource(pcmk_node_t node, const xmlNode lrm_resource,
	pcmk_scheduler_t *scheduler)
	{
	GList *gIter = NULL;
	int stop_index = -1;
	int start_index = -1;
	enum rsc_role_e req_role = pcmk_role_unknown;

	const char *rsc_id = pcmk__xe_id(lrm_resource);

	pcmk_resource_t *rsc = NULL;
	GList *op_list = NULL;
	GList *sorted_op_list = NULL;

	xmlNode *rsc_op = NULL;
	xmlNode *last_failure = NULL;

	enum pcmk__on_fail on_fail = pcmk__on_fail_ignore;
	enum rsc_role_e saved_role = pcmk_role_unknown;

	if (rsc_id == NULL) {
	pcmk__config_err("Ignoring invalid " PCMK__XE_LRM_RESOURCE
	" entry: No " PCMK_XA_ID);
	crm_log_xml_info(lrm_resource, "missing-id");
	return NULL;
	}
	crm_trace("Unpacking " PCMK__XE_LRM_RESOURCE " for %s on %s",
	rsc_id, pcmk__node_name(node));

	/* Build a list of individual PCMK__XE_LRM_RSC_OP entries, so we can sort
	* them
	*/
	for (rsc_op = pcmk__xe_first_child(lrm_resource, PCMK__XE_LRM_RSC_OP, NULL,
	NULL);
	rsc_op != NULL; rsc_op = pcmk__xe_next_same(rsc_op)) {

	op_list = g_list_prepend(op_list, rsc_op);
	}

	if (!pcmk_is_set(scheduler->flags, pcmk_sched_shutdown_lock)) {
	if (op_list == NULL) {
	// If there are no operations, there is nothing to do
	return NULL;
	}
	}

	/* find the resource */
	rsc = unpack_find_resource(scheduler, node, rsc_id);
	if (rsc == NULL) {
	if (op_list == NULL) {
	// If there are no operations, there is nothing to do
	return NULL;
	} else {
	rsc = process_orphan_resource(lrm_resource, node, scheduler);
	}
	}
	CRM_ASSERT(rsc != NULL);

	// Check whether the resource is "shutdown-locked" to this node
	if (pcmk_is_set(scheduler->flags, pcmk_sched_shutdown_lock)) {
	unpack_shutdown_lock(lrm_resource, rsc, node, scheduler);
	}

	/* process operations */
	saved_role = rsc->private->orig_role;
	rsc->private->orig_role = pcmk_role_unknown;
	sorted_op_list = g_list_sort(op_list, sort_op_by_callid);

	for (gIter = sorted_op_list; gIter != NULL; gIter = gIter->next) {
	xmlNode rsc_op = (xmlNode ) gIter->data;

	unpack_rsc_op(rsc, node, rsc_op, &last_failure, &on_fail);
	}

	/* create active recurring operations as optional */
	calculate_active_ops(sorted_op_list, &start_index, &stop_index);
	process_recurring(node, rsc, start_index, stop_index, sorted_op_list,
	scheduler);

	/* no need to free the contents */
	g_list_free(sorted_op_list);

	process_rsc_state(rsc, node, on_fail);

	if (get_target_role(rsc, &req_role)) {
	if ((rsc->private->next_role == pcmk_role_unknown)
	\|\| (req_role < rsc->private->next_role)) {

	pe__set_next_role(rsc, req_role, PCMK_META_TARGET_ROLE);

	} else if (req_role > rsc->private->next_role) {
	pcmk__rsc_info(rsc,
	"%s: Not overwriting calculated next role %s"
	" with requested next role %s",
	rsc->id, pcmk_role_text(rsc->private->next_role),
	pcmk_role_text(req_role));
	}
	}

	if (saved_role > rsc->private->orig_role) {
	rsc->private->orig_role = saved_role;
	}

	return rsc;
	}

	static void
	handle_removed_launched_resources(const xmlNode *lrm_rsc_list,
	pcmk_scheduler_t *scheduler)
	{
	for (const xmlNode *rsc_entry = pcmk__xe_first_child(lrm_rsc_list, NULL,
	NULL, NULL);
	rsc_entry != NULL; rsc_entry = pcmk__xe_next(rsc_entry)) {

	pcmk_resource_t *rsc;
	pcmk_resource_t *launcher = NULL;
	const char *rsc_id;
	const char *launcher_id = NULL;

	if (!pcmk__xe_is(rsc_entry, PCMK__XE_LRM_RESOURCE)) {
	continue;
	}

	launcher_id = crm_element_value(rsc_entry, PCMK__META_CONTAINER);
	rsc_id = crm_element_value(rsc_entry, PCMK_XA_ID);
	if ((launcher_id == NULL) \|\| (rsc_id == NULL)) {
	continue;
	}

	launcher = pe_find_resource(scheduler->resources, launcher_id);
	if (launcher == NULL) {
	continue;
	}

	rsc = pe_find_resource(scheduler->resources, rsc_id);
	if ((rsc == NULL) \|\| (rsc->private->launcher != NULL)
	\|\| !pcmk_is_set(rsc->flags, pcmk__rsc_removed_launched)) {
	continue;
	}

	pcmk__rsc_trace(rsc, "Mapped launcher of removed resource %s to %s",
	rsc->id, launcher_id);
	rsc->private->launcher = launcher;
	launcher->private->launched = g_list_append(launcher->private->launched,
	rsc);
	}
	}

	/*!
	* \internal
	* \brief Unpack one node's lrm status section
	*
	* \param[in,out] node Node whose status is being unpacked
	* \param[in] xml CIB node state XML
	* \param[in,out] scheduler Scheduler data
	*/
	static void
	unpack_node_lrm(pcmk_node_t node, const xmlNode xml,
	pcmk_scheduler_t *scheduler)
	{
	bool found_removed_launched_resource = false;

	// Drill down to PCMK__XE_LRM_RESOURCES section
	xml = pcmk__xe_first_child(xml, PCMK__XE_LRM, NULL, NULL);
	if (xml == NULL) {
	return;
	}
	xml = pcmk__xe_first_child(xml, PCMK__XE_LRM_RESOURCES, NULL, NULL);
	if (xml == NULL) {
	return;
	}

	// Unpack each PCMK__XE_LRM_RESOURCE entry
	for (const xmlNode *rsc_entry = pcmk__xe_first_child(xml,
	PCMK__XE_LRM_RESOURCE,
	NULL, NULL);
	rsc_entry != NULL; rsc_entry = pcmk__xe_next_same(rsc_entry)) {

	pcmk_resource_t *rsc = unpack_lrm_resource(node, rsc_entry, scheduler);

	if ((rsc != NULL)
	&& pcmk_is_set(rsc->flags, pcmk__rsc_removed_launched)) {
	found_removed_launched_resource = true;
	}
	}

	/* Now that all resource state has been unpacked for this node, map any
	* removed launched resources to their launchers.
	*/
	if (found_removed_launched_resource) {
	handle_removed_launched_resources(xml, scheduler);
	}
	}

	static void
	set_active(pcmk_resource_t *rsc)
	{
	const pcmk_resource_t *top = pe__const_top_resource(rsc, false);

	if (top && pcmk_is_set(top->flags, pcmk__rsc_promotable)) {
	rsc->private->orig_role = pcmk_role_unpromoted;
	} else {
	rsc->private->orig_role = pcmk_role_started;
	}
	}

	static void
	set_node_score(gpointer key, gpointer value, gpointer user_data)
	{
	pcmk_node_t *node = value;
	int *score = user_data;

	node->assign->score = *score;
	}

	#define XPATH_NODE_STATE "/" PCMK_XE_CIB "/" PCMK_XE_STATUS \
	"/" PCMK__XE_NODE_STATE
	#define SUB_XPATH_LRM_RESOURCE "/" PCMK__XE_LRM \
	"/" PCMK__XE_LRM_RESOURCES \
	"/" PCMK__XE_LRM_RESOURCE
	#define SUB_XPATH_LRM_RSC_OP "/" PCMK__XE_LRM_RSC_OP

	static xmlNode *
	find_lrm_op(const char resource, const char op, const char node, const char source,
	int target_rc, pcmk_scheduler_t *scheduler)
	{
	GString *xpath = NULL;
	xmlNode *xml = NULL;

	CRM_CHECK((resource != NULL) && (op != NULL) && (node != NULL),
	return NULL);

	xpath = g_string_sized_new(256);
	pcmk__g_strcat(xpath,
	XPATH_NODE_STATE "[@" PCMK_XA_UNAME "='", node, "']"
	SUB_XPATH_LRM_RESOURCE "[@" PCMK_XA_ID "='", resource, "']"
	SUB_XPATH_LRM_RSC_OP "[@" PCMK_XA_OPERATION "='", op, "'",
	NULL);

	/* Need to check against transition_magic too? */
	if ((source != NULL) && (strcmp(op, PCMK_ACTION_MIGRATE_TO) == 0)) {
	pcmk__g_strcat(xpath,
	" and @" PCMK__META_MIGRATE_TARGET "='", source, "']",
	NULL);

	} else if ((source != NULL)
	&& (strcmp(op, PCMK_ACTION_MIGRATE_FROM) == 0)) {
	pcmk__g_strcat(xpath,
	" and @" PCMK__META_MIGRATE_SOURCE "='", source, "']",
	NULL);
	} else {
	g_string_append_c(xpath, ']');
	}

	xml = get_xpath_object((const char *) xpath->str, scheduler->input,
	LOG_DEBUG);
	g_string_free(xpath, TRUE);

	if (xml && target_rc >= 0) {
	int rc = PCMK_OCF_UNKNOWN_ERROR;
	int status = PCMK_EXEC_ERROR;

	crm_element_value_int(xml, PCMK__XA_RC_CODE, &rc);
	crm_element_value_int(xml, PCMK__XA_OP_STATUS, &status);
	if ((rc != target_rc) \|\| (status != PCMK_EXEC_DONE)) {
	return NULL;
	}
	}
	return xml;
	}

	static xmlNode *
	find_lrm_resource(const char rsc_id, const char node_name,
	pcmk_scheduler_t *scheduler)
	{
	GString *xpath = NULL;
	xmlNode *xml = NULL;

	CRM_CHECK((rsc_id != NULL) && (node_name != NULL), return NULL);

	xpath = g_string_sized_new(256);
	pcmk__g_strcat(xpath,
	XPATH_NODE_STATE "[@" PCMK_XA_UNAME "='", node_name, "']"
	SUB_XPATH_LRM_RESOURCE "[@" PCMK_XA_ID "='", rsc_id, "']",
	NULL);

	xml = get_xpath_object((const char *) xpath->str, scheduler->input,
	LOG_DEBUG);

	g_string_free(xpath, TRUE);
	return xml;
	}

	/*!
	* \internal
	* \brief Check whether a resource has no completed action history on a node
	*
	* \param[in,out] rsc Resource to check
	* \param[in] node_name Node to check
	*
	* \return true if \p rsc_id is unknown on \p node_name, otherwise false
	*/
	static bool
	unknown_on_node(pcmk_resource_t rsc, const char node_name)
	{
	bool result = false;
	xmlXPathObjectPtr search;
	char *xpath = NULL;

	xpath = crm_strdup_printf(XPATH_NODE_STATE "[@" PCMK_XA_UNAME "='%s']"
	SUB_XPATH_LRM_RESOURCE "[@" PCMK_XA_ID "='%s']"
	SUB_XPATH_LRM_RSC_OP
	"[@" PCMK__XA_RC_CODE "!='%d']",
	node_name, rsc->id, PCMK_OCF_UNKNOWN);

	search = xpath_search(rsc->private->scheduler->input, xpath);
	result = (numXpathResults(search) == 0);
	freeXpathObject(search);
	free(xpath);
	return result;
	}

	/*!
	* \internal
	* \brief Check whether a probe/monitor indicating the resource was not running
	* on a node happened after some event
	*
	* \param[in] rsc_id Resource being checked
	* \param[in] node_name Node being checked
	* \param[in] xml_op Event that monitor is being compared to
	* \param[in,out] scheduler Scheduler data
	*
	* \return true if such a monitor happened after event, false otherwise
	*/
	static bool
	monitor_not_running_after(const char rsc_id, const char node_name,
	const xmlNode xml_op, pcmk_scheduler_t scheduler)
	{
	/* Any probe/monitor operation on the node indicating it was not running
	* there
	*/
	xmlNode *monitor = find_lrm_op(rsc_id, PCMK_ACTION_MONITOR, node_name,
	NULL, PCMK_OCF_NOT_RUNNING, scheduler);

	return (monitor != NULL) && (pe__is_newer_op(monitor, xml_op) > 0);
	}

	/*!
	* \internal
	* \brief Check whether any non-monitor operation on a node happened after some
	* event
	*
	* \param[in] rsc_id Resource being checked
	* \param[in] node_name Node being checked
	* \param[in] xml_op Event that non-monitor is being compared to
	* \param[in,out] scheduler Scheduler data
	*
	* \return true if such a operation happened after event, false otherwise
	*/
	static bool
	non_monitor_after(const char rsc_id, const char node_name,
	const xmlNode xml_op, pcmk_scheduler_t scheduler)
	{
	xmlNode *lrm_resource = NULL;

	lrm_resource = find_lrm_resource(rsc_id, node_name, scheduler);
	if (lrm_resource == NULL) {
	return false;
	}

	for (xmlNode *op = pcmk__xe_first_child(lrm_resource, PCMK__XE_LRM_RSC_OP,
	NULL, NULL);
	op != NULL; op = pcmk__xe_next_same(op)) {

	const char * task = NULL;

	if (op == xml_op) {
	continue;
	}

	task = crm_element_value(op, PCMK_XA_OPERATION);

	if (pcmk__str_any_of(task, PCMK_ACTION_START, PCMK_ACTION_STOP,
	PCMK_ACTION_MIGRATE_TO, PCMK_ACTION_MIGRATE_FROM,
	NULL)
	&& pe__is_newer_op(op, xml_op) > 0) {
	return true;
	}
	}

	return false;
	}

	/*!
	* \internal
	* \brief Check whether the resource has newer state on a node after a migration
	* attempt
	*
	* \param[in] rsc_id Resource being checked
	* \param[in] node_name Node being checked
	* \param[in] migrate_to Any migrate_to event that is being compared to
	* \param[in] migrate_from Any migrate_from event that is being compared to
	* \param[in,out] scheduler Scheduler data
	*
	* \return true if such a operation happened after event, false otherwise
	*/
	static bool
	newer_state_after_migrate(const char rsc_id, const char node_name,
	const xmlNode *migrate_to,
	const xmlNode *migrate_from,
	pcmk_scheduler_t *scheduler)
	{
	const xmlNode *xml_op = (migrate_from != NULL)? migrate_from : migrate_to;
	const char *source = crm_element_value(xml_op, PCMK__META_MIGRATE_SOURCE);

	/* It's preferred to compare to the migrate event on the same node if
	* existing, since call ids are more reliable.
	*/
	if ((xml_op != migrate_to) && (migrate_to != NULL)
	&& pcmk__str_eq(node_name, source, pcmk__str_casei)) {

	xml_op = migrate_to;
	}

	/* If there's any newer non-monitor operation on the node, or any newer
	* probe/monitor operation on the node indicating it was not running there,
	* the migration events potentially no longer matter for the node.
	*/
	return non_monitor_after(rsc_id, node_name, xml_op, scheduler)
	\|\| monitor_not_running_after(rsc_id, node_name, xml_op, scheduler);
	}

	/*!
	* \internal
	* \brief Parse migration source and target node names from history entry
	*
	* \param[in] entry Resource history entry for a migration action
	* \param[in] source_node If not NULL, source must match this node
	* \param[in] target_node If not NULL, target must match this node
	* \param[out] source_name Where to store migration source node name
	* \param[out] target_name Where to store migration target node name
	*
	* \return Standard Pacemaker return code
	*/
	static int
	get_migration_node_names(const xmlNode entry, const pcmk_node_t source_node,
	const pcmk_node_t *target_node,
	const char source_name, const char target_name)
	{
	*source_name = crm_element_value(entry, PCMK__META_MIGRATE_SOURCE);
	*target_name = crm_element_value(entry, PCMK__META_MIGRATE_TARGET);
	if ((source_name == NULL) \|\| (target_name == NULL)) {
	pcmk__config_err("Ignoring resource history entry %s without "
	PCMK__META_MIGRATE_SOURCE " and "
	PCMK__META_MIGRATE_TARGET, pcmk__xe_id(entry));
	return pcmk_rc_unpack_error;
	}

	if ((source_node != NULL)
	&& !pcmk__str_eq(*source_name, source_node->private->name,
	pcmk__str_casei\|pcmk__str_null_matches)) {
	pcmk__config_err("Ignoring resource history entry %s because "
	PCMK__META_MIGRATE_SOURCE "='%s' does not match %s",
	pcmk__xe_id(entry), *source_name,
	pcmk__node_name(source_node));
	return pcmk_rc_unpack_error;
	}

	if ((target_node != NULL)
	&& !pcmk__str_eq(*target_name, target_node->private->name,
	pcmk__str_casei\|pcmk__str_null_matches)) {
	pcmk__config_err("Ignoring resource history entry %s because "
	PCMK__META_MIGRATE_TARGET "='%s' does not match %s",
	pcmk__xe_id(entry), *target_name,
	pcmk__node_name(target_node));
	return pcmk_rc_unpack_error;
	}

	return pcmk_rc_ok;
	}

	/*
	* \internal
	* \brief Add a migration source to a resource's list of dangling migrations
	*
	* If the migrate_to and migrate_from actions in a live migration both
	* succeeded, but there is no stop on the source, the migration is considered
	* "dangling." Add the source to the resource's dangling migration list, which
	* will be used to schedule a stop on the source without affecting the target.
	*
	* \param[in,out] rsc Resource involved in migration
	* \param[in] node Migration source
	*/
	static void
	add_dangling_migration(pcmk_resource_t rsc, const pcmk_node_t node)
	{
	pcmk__rsc_trace(rsc, "Dangling migration of %s requires stop on %s",
	rsc->id, pcmk__node_name(node));
	rsc->private->orig_role = pcmk_role_stopped;
	rsc->private->dangling_migration_sources =
	g_list_prepend(rsc->private->dangling_migration_sources,
	(gpointer) node);
	}

	/*!
	* \internal
	* \brief Update resource role etc. after a successful migrate_to action
	*
	* \param[in,out] history Parsed action result history
	*/
	static void
	unpack_migrate_to_success(struct action_history *history)
	{
	/* A complete migration sequence is:
	* 1. migrate_to on source node (which succeeded if we get to this function)
	* 2. migrate_from on target node
	* 3. stop on source node
	*
	* If no migrate_from has happened, the migration is considered to be
	* "partial". If the migrate_from succeeded but no stop has happened, the
	* migration is considered to be "dangling".
	*
	* If a successful migrate_to and stop have happened on the source node, we
	* still need to check for a partial migration, due to scenarios (easier to
	* produce with batch-limit=1) like:
	*
	* - A resource is migrating from node1 to node2, and a migrate_to is
	* initiated for it on node1.
	*
	* - node2 goes into standby mode while the migrate_to is pending, which
	* aborts the transition.
	*
	* - Upon completion of the migrate_to, a new transition schedules a stop
	* on both nodes and a start on node1.
	*
	* - If the new transition is aborted for any reason while the resource is
	* stopping on node1, the transition after that stop completes will see
	* the migrate_to and stop on the source, but it's still a partial
	* migration, and the resource must be stopped on node2 because it is
	* potentially active there due to the migrate_to.
	*
	* We also need to take into account that either node's history may be
	* cleared at any point in the migration process.
	*/
	int from_rc = PCMK_OCF_OK;
	int from_status = PCMK_EXEC_PENDING;
	pcmk_node_t *target_node = NULL;
	xmlNode *migrate_from = NULL;
	const char *source = NULL;
	const char *target = NULL;
	bool source_newer_op = false;
	bool target_newer_state = false;
	bool active_on_target = false;
	pcmk_scheduler_t *scheduler = history->rsc->private->scheduler;

	// Get source and target node names from XML
	if (get_migration_node_names(history->xml, history->node, NULL, &source,
	&target) != pcmk_rc_ok) {
	return;
	}

	// Check for newer state on the source
	source_newer_op = non_monitor_after(history->rsc->id, source, history->xml,
	scheduler);

	// Check for a migrate_from action from this source on the target
	migrate_from = find_lrm_op(history->rsc->id, PCMK_ACTION_MIGRATE_FROM,
	target, source, -1, scheduler);
	if (migrate_from != NULL) {
	if (source_newer_op) {
	/* There's a newer non-monitor operation on the source and a
	* migrate_from on the target, so this migrate_to is irrelevant to
	* the resource's state.
	*/
	return;
	}
	crm_element_value_int(migrate_from, PCMK__XA_RC_CODE, &from_rc);
	crm_element_value_int(migrate_from, PCMK__XA_OP_STATUS, &from_status);
	}

	/* If the resource has newer state on both the source and target after the
	* migration events, this migrate_to is irrelevant to the resource's state.
	*/
	target_newer_state = newer_state_after_migrate(history->rsc->id, target,
	history->xml, migrate_from,
	scheduler);
	if (source_newer_op && target_newer_state) {
	return;
	}

	/* Check for dangling migration (migrate_from succeeded but stop not done).
	* We know there's no stop because we already returned if the target has a
	* migrate_from and the source has any newer non-monitor operation.
	*/
	if ((from_rc == PCMK_OCF_OK) && (from_status == PCMK_EXEC_DONE)) {
	add_dangling_migration(history->rsc, history->node);
	return;
	}

	/* Without newer state, this migrate_to implies the resource is active.
	* (Clones are not allowed to migrate, so role can't be promoted.)
	*/
	history->rsc->private->orig_role = pcmk_role_started;

	target_node = pcmk_find_node(scheduler, target);
	active_on_target = !target_newer_state && (target_node != NULL)
	&& target_node->details->online;

	if (from_status != PCMK_EXEC_PENDING) { // migrate_from failed on target
	if (active_on_target) {
	native_add_running(history->rsc, target_node, scheduler, TRUE);
	} else {
	// Mark resource as failed, require recovery, and prevent migration
	pcmk__set_rsc_flags(history->rsc,
	pcmk__rsc_failed\|pcmk__rsc_stop_if_failed);
	pcmk__clear_rsc_flags(history->rsc, pcmk__rsc_migratable);
	}
	return;
	}

	// The migrate_from is pending, complete but erased, or to be scheduled

	/* If there is no history at all for the resource on an online target, then
	* it was likely cleaned. Just return, and we'll schedule a probe. Once we
	* have the probe result, it will be reflected in target_newer_state.
	*/
	if ((target_node != NULL) && target_node->details->online
	&& unknown_on_node(history->rsc, target)) {
	return;
	}

	if (active_on_target) {
	pcmk_node_t *source_node = pcmk_find_node(scheduler, source);

	native_add_running(history->rsc, target_node, scheduler, FALSE);
	if ((source_node != NULL) && source_node->details->online) {
	/* This is a partial migration: the migrate_to completed
	* successfully on the source, but the migrate_from has not
	* completed. Remember the source and target; if the newly
	* chosen target remains the same when we schedule actions
	* later, we may continue with the migration.
	*/
	history->rsc->private->partial_migration_target = target_node;
	history->rsc->private->partial_migration_source = source_node;
	}

	} else if (!source_newer_op) {
	// Mark resource as failed, require recovery, and prevent migration
	pcmk__set_rsc_flags(history->rsc,
	pcmk__rsc_failed\|pcmk__rsc_stop_if_failed);
	pcmk__clear_rsc_flags(history->rsc, pcmk__rsc_migratable);
	}
	}

	/*!
	* \internal
	* \brief Update resource role etc. after a failed migrate_to action
	*
	* \param[in,out] history Parsed action result history
	*/
	static void
	unpack_migrate_to_failure(struct action_history *history)
	{
	xmlNode *target_migrate_from = NULL;
	const char *source = NULL;
	const char *target = NULL;
	pcmk_scheduler_t *scheduler = history->rsc->private->scheduler;

	// Get source and target node names from XML
	if (get_migration_node_names(history->xml, history->node, NULL, &source,
	&target) != pcmk_rc_ok) {
	return;
	}

	/* If a migration failed, we have to assume the resource is active. Clones
	* are not allowed to migrate, so role can't be promoted.
	*/
	history->rsc->private->orig_role = pcmk_role_started;

	// Check for migrate_from on the target
	target_migrate_from = find_lrm_op(history->rsc->id,
	PCMK_ACTION_MIGRATE_FROM, target, source,
	PCMK_OCF_OK, scheduler);

	if (/* If the resource state is unknown on the target, it will likely be
	* probed there.
	* Don't just consider it running there. We will get back here anyway in
	* case the probe detects it's running there.
	*/
	!unknown_on_node(history->rsc, target)
	/* If the resource has newer state on the target after the migration
	* events, this migrate_to no longer matters for the target.
	*/
	&& !newer_state_after_migrate(history->rsc->id, target, history->xml,
	target_migrate_from, scheduler)) {
	/* The resource has no newer state on the target, so assume it's still
	* active there.
	* (if it is up).
	*/
	pcmk_node_t *target_node = pcmk_find_node(scheduler, target);

	if (target_node && target_node->details->online) {
	native_add_running(history->rsc, target_node, scheduler, FALSE);
	}

	} else if (!non_monitor_after(history->rsc->id, source, history->xml,
	scheduler)) {
	/* We know the resource has newer state on the target, but this
	* migrate_to still matters for the source as long as there's no newer
	* non-monitor operation there.
	*/

	// Mark node as having dangling migration so we can force a stop later
	history->rsc->private->dangling_migration_sources =
	g_list_prepend(history->rsc->private->dangling_migration_sources,
	(gpointer) history->node);
	}
	}

	/*!
	* \internal
	* \brief Update resource role etc. after a failed migrate_from action
	*
	* \param[in,out] history Parsed action result history
	*/
	static void
	unpack_migrate_from_failure(struct action_history *history)
	{
	xmlNode *source_migrate_to = NULL;
	const char *source = NULL;
	const char *target = NULL;
	pcmk_scheduler_t *scheduler = history->rsc->private->scheduler;

	// Get source and target node names from XML
	if (get_migration_node_names(history->xml, NULL, history->node, &source,
	&target) != pcmk_rc_ok) {
	return;
	}

	/* If a migration failed, we have to assume the resource is active. Clones
	* are not allowed to migrate, so role can't be promoted.
	*/
	history->rsc->private->orig_role = pcmk_role_started;

	// Check for a migrate_to on the source
	source_migrate_to = find_lrm_op(history->rsc->id, PCMK_ACTION_MIGRATE_TO,
	source, target, PCMK_OCF_OK, scheduler);

	if (/* If the resource state is unknown on the source, it will likely be
	* probed there.
	* Don't just consider it running there. We will get back here anyway in
	* case the probe detects it's running there.
	*/
	!unknown_on_node(history->rsc, source)
	/* If the resource has newer state on the source after the migration
	* events, this migrate_from no longer matters for the source.
	*/
	&& !newer_state_after_migrate(history->rsc->id, source,
	source_migrate_to, history->xml,
	scheduler)) {
	/* The resource has no newer state on the source, so assume it's still
	* active there (if it is up).
	*/
	pcmk_node_t *source_node = pcmk_find_node(scheduler, source);

	if (source_node && source_node->details->online) {
	native_add_running(history->rsc, source_node, scheduler, TRUE);
	}
	}
	}

	/*!
	* \internal
	* \brief Add an action to cluster's list of failed actions
	*
	* \param[in,out] history Parsed action result history
	*/
	static void
	record_failed_op(struct action_history *history)
	{
	const pcmk_scheduler_t *scheduler = history->rsc->private->scheduler;

	if (!(history->node->details->online)) {
	return;
	}

	for (const xmlNode *xIter = scheduler->failed->children;
	xIter != NULL; xIter = xIter->next) {

	const char *key = pcmk__xe_history_key(xIter);
	const char *uname = crm_element_value(xIter, PCMK_XA_UNAME);

	if (pcmk__str_eq(history->key, key, pcmk__str_none)
	&& pcmk__str_eq(uname, history->node->private->name,
	pcmk__str_casei)) {
	crm_trace("Skipping duplicate entry %s on %s",
	history->key, pcmk__node_name(history->node));
	return;
	}
	}

	crm_trace("Adding entry for %s on %s to failed action list",
	history->key, pcmk__node_name(history->node));
	crm_xml_add(history->xml, PCMK_XA_UNAME, history->node->private->name);
	crm_xml_add(history->xml, PCMK__XA_RSC_ID, history->rsc->id);
	pcmk__xml_copy(scheduler->failed, history->xml);
	}

	static char *
	last_change_str(const xmlNode *xml_op)
	{
	time_t when;
	char *result = NULL;

	if (crm_element_value_epoch(xml_op, PCMK_XA_LAST_RC_CHANGE,
	&when) == pcmk_ok) {
	char *when_s = pcmk__epoch2str(&when, 0);
	const char *p = strchr(when_s, ' ');

	// Skip day of week to make message shorter
	if ((p != NULL) && (*(++p) != '\0')) {
	result = pcmk__str_copy(p);
	}
	free(when_s);
	}

	if (result == NULL) {
	result = pcmk__str_copy("unknown_time");
	}

	return result;
	}

	/*!
	* \internal
	* \brief Ban a resource (or its clone if an anonymous instance) from all nodes
	*
	* \param[in,out] rsc Resource to ban
	*/
	static void
	ban_from_all_nodes(pcmk_resource_t *rsc)
	{
	int score = -PCMK_SCORE_INFINITY;
	const pcmk_scheduler_t *scheduler = rsc->private->scheduler;

	if (rsc->private->parent != NULL) {
	pcmk_resource_t *parent = uber_parent(rsc);

	if (pcmk__is_anonymous_clone(parent)) {
	/* For anonymous clones, if an operation with
	* PCMK_META_ON_FAIL=PCMK_VALUE_STOP fails for any instance, the
	* entire clone must stop.
	*/
	rsc = parent;
	}
	}

	// Ban the resource from all nodes
	crm_notice("%s will not be started under current conditions", rsc->id);
	if (rsc->private->allowed_nodes != NULL) {
	g_hash_table_destroy(rsc->private->allowed_nodes);
	}
	rsc->private->allowed_nodes = pe__node_list2table(scheduler->nodes);
	g_hash_table_foreach(rsc->private->allowed_nodes, set_node_score, &score);
	}

	/*!
	* \internal
	* \brief Get configured failure handling and role after failure for an action
	*
	* \param[in,out] history Unpacked action history entry
	* \param[out] on_fail Where to set configured failure handling
	* \param[out] fail_role Where to set to role after failure
	*/
	static void
	unpack_failure_handling(struct action_history *history,
	enum pcmk__on_fail *on_fail,
	enum rsc_role_e *fail_role)
	{
	xmlNode *config = pcmk__find_action_config(history->rsc, history->task,
	history->interval_ms, true);

	GHashTable *meta = pcmk__unpack_action_meta(history->rsc, history->node,
	history->task,
	history->interval_ms, config);

	const char *on_fail_str = g_hash_table_lookup(meta, PCMK_META_ON_FAIL);

	*on_fail = pcmk__parse_on_fail(history->rsc, history->task,
	history->interval_ms, on_fail_str);
	fail_role = pcmk__role_after_failure(history->rsc, history->task, on_fail,
	meta);
	g_hash_table_destroy(meta);
	}

	/*!
	* \internal
	* \brief Update resource role, failure handling, etc., after a failed action
	*
	* \param[in,out] history Parsed action result history
	* \param[in] config_on_fail Action failure handling from configuration
	* \param[in] fail_role Resource's role after failure of this action
	* \param[out] last_failure This will be set to the history XML
	* \param[in,out] on_fail Actual handling of action result
	*/
	static void
	unpack_rsc_op_failure(struct action_history *history,
	enum pcmk__on_fail config_on_fail,
	enum rsc_role_e fail_role, xmlNode **last_failure,
	enum pcmk__on_fail *on_fail)
	{
	bool is_probe = false;
	char *last_change_s = NULL;
	pcmk_scheduler_t *scheduler = history->rsc->private->scheduler;

	*last_failure = history->xml;

	is_probe = pcmk_xe_is_probe(history->xml);
	last_change_s = last_change_str(history->xml);

	if (!pcmk_is_set(scheduler->flags, pcmk_sched_symmetric_cluster)
	&& (history->exit_status == PCMK_OCF_NOT_INSTALLED)) {
	crm_trace("Unexpected result (%s%s%s) was recorded for "
	"%s of %s on %s at %s " QB_XS " exit-status=%d id=%s",
	services_ocf_exitcode_str(history->exit_status),
	(pcmk__str_empty(history->exit_reason)? "" : ": "),
	pcmk__s(history->exit_reason, ""),
	(is_probe? "probe" : history->task), history->rsc->id,
	pcmk__node_name(history->node), last_change_s,
	history->exit_status, history->id);
	} else {
	pcmk__sched_warn("Unexpected result (%s%s%s) was recorded for %s of "
	"%s on %s at %s " QB_XS " exit-status=%d id=%s",
	services_ocf_exitcode_str(history->exit_status),
	(pcmk__str_empty(history->exit_reason)? "" : ": "),
	pcmk__s(history->exit_reason, ""),
	(is_probe? "probe" : history->task), history->rsc->id,
	pcmk__node_name(history->node), last_change_s,
	history->exit_status, history->id);

	if (is_probe && (history->exit_status != PCMK_OCF_OK)
	&& (history->exit_status != PCMK_OCF_NOT_RUNNING)
	&& (history->exit_status != PCMK_OCF_RUNNING_PROMOTED)) {

	/* A failed (not just unexpected) probe result could mean the user
	* didn't know resources will be probed even where they can't run.
	*/
	crm_notice("If it is not possible for %s to run on %s, see "
	"the " PCMK_XA_RESOURCE_DISCOVERY " option for location "
	"constraints",
	history->rsc->id, pcmk__node_name(history->node));
	}

	record_failed_op(history);
	}

	free(last_change_s);

	if (*on_fail < config_on_fail) {
	pcmk__rsc_trace(history->rsc, "on-fail %s -> %s for %s",
	pcmk__on_fail_text(*on_fail),
	pcmk__on_fail_text(config_on_fail), history->key);
	*on_fail = config_on_fail;
	}

	if (strcmp(history->task, PCMK_ACTION_STOP) == 0) {
	resource_location(history->rsc, history->node, -PCMK_SCORE_INFINITY,
	"__stop_fail__", scheduler);

	} else if (strcmp(history->task, PCMK_ACTION_MIGRATE_TO) == 0) {
	unpack_migrate_to_failure(history);

	} else if (strcmp(history->task, PCMK_ACTION_MIGRATE_FROM) == 0) {
	unpack_migrate_from_failure(history);

	} else if (strcmp(history->task, PCMK_ACTION_PROMOTE) == 0) {
	history->rsc->private->orig_role = pcmk_role_promoted;

	} else if (strcmp(history->task, PCMK_ACTION_DEMOTE) == 0) {
	if (config_on_fail == pcmk__on_fail_block) {
	history->rsc->private->orig_role = pcmk_role_promoted;
	pe__set_next_role(history->rsc, pcmk_role_stopped,
	"demote with " PCMK_META_ON_FAIL "=block");

	} else if (history->exit_status == PCMK_OCF_NOT_RUNNING) {
	history->rsc->private->orig_role = pcmk_role_stopped;

	} else {
	/* Staying in the promoted role would put the scheduler and
	* controller into a loop. Setting the role to unpromoted is not
	* dangerous because the resource will be stopped as part of
	* recovery, and any promotion will be ordered after that stop.
	*/
	history->rsc->private->orig_role = pcmk_role_unpromoted;
	}
	}

	if (is_probe && (history->exit_status == PCMK_OCF_NOT_INSTALLED)) {
	/* leave stopped */
	pcmk__rsc_trace(history->rsc, "Leaving %s stopped", history->rsc->id);
	history->rsc->private->orig_role = pcmk_role_stopped;

	} else if (history->rsc->private->orig_role < pcmk_role_started) {
	pcmk__rsc_trace(history->rsc, "Setting %s active", history->rsc->id);
	set_active(history->rsc);
	}

	pcmk__rsc_trace(history->rsc,
	"Resource %s: role=%s unclean=%s on_fail=%s fail_role=%s",
	history->rsc->id,
	pcmk_role_text(history->rsc->private->orig_role),
	pcmk__btoa(history->node->details->unclean),
	pcmk__on_fail_text(config_on_fail),
	pcmk_role_text(fail_role));

	if ((fail_role != pcmk_role_started)
	&& (history->rsc->private->next_role < fail_role)) {
	pe__set_next_role(history->rsc, fail_role, "failure");
	}

	if (fail_role == pcmk_role_stopped) {
	ban_from_all_nodes(history->rsc);
	}
	}

	/*!
	* \internal
	* \brief Block a resource with a failed action if it cannot be recovered
	*
	* If resource action is a failed stop and fencing is not possible, mark the
	* resource as unmanaged and blocked, since recovery cannot be done.
	*
	* \param[in,out] history Parsed action history entry
	*/
	static void
	block_if_unrecoverable(struct action_history *history)
	{
	char *last_change_s = NULL;

	if (strcmp(history->task, PCMK_ACTION_STOP) != 0) {
	return; // All actions besides stop are always recoverable
	}
	if (pe_can_fence(history->node->private->scheduler, history->node)) {
	return; // Failed stops are recoverable via fencing
	}

	last_change_s = last_change_str(history->xml);
	pcmk__sched_err("No further recovery can be attempted for %s "
	"because %s on %s failed (%s%s%s) at %s "
	QB_XS " rc=%d id=%s",
	history->rsc->id, history->task,
	pcmk__node_name(history->node),
	services_ocf_exitcode_str(history->exit_status),
	(pcmk__str_empty(history->exit_reason)? "" : ": "),
	pcmk__s(history->exit_reason, ""),
	last_change_s, history->exit_status, history->id);

	free(last_change_s);

	pcmk__clear_rsc_flags(history->rsc, pcmk__rsc_managed);
	pcmk__set_rsc_flags(history->rsc, pcmk__rsc_blocked);
	}

	/*!
	* \internal
	* \brief Update action history's execution status and why
	*
	* \param[in,out] history Parsed action history entry
	* \param[out] why Where to store reason for update
	* \param[in] value New value
	* \param[in] reason Description of why value was changed
	*/
	static inline void
	remap_because(struct action_history history, const char *why, int value,
	const char *reason)
	{
	if (history->execution_status != value) {
	history->execution_status = value;
	*why = reason;
	}
	}

	/*!
	* \internal
	* \brief Remap informational monitor results and operation status
	*
	* For the monitor results, certain OCF codes are for providing extended information
	* to the user about services that aren't yet failed but not entirely healthy either.
	* These must be treated as the "normal" result by Pacemaker.
	*
	* For operation status, the action result can be used to determine an appropriate
	* status for the purposes of responding to the action. The status provided by the
	* executor is not directly usable since the executor does not know what was expected.
	*
	* \param[in,out] history Parsed action history entry
	* \param[in,out] on_fail What should be done about the result
	* \param[in] expired Whether result is expired
	*
	* \note If the result is remapped and the node is not shutting down or failed,
	* the operation will be recorded in the scheduler data's list of failed
	* operations to highlight it for the user.
	*
	* \note This may update the resource's current and next role.
	*/
	static void
	remap_operation(struct action_history *history,
	enum pcmk__on_fail *on_fail, bool expired)
	{
	bool is_probe = false;
	int orig_exit_status = history->exit_status;
	int orig_exec_status = history->execution_status;
	const char *why = NULL;
	const char *task = history->task;

	// Remap degraded results to their successful counterparts
	history->exit_status = pcmk__effective_rc(history->exit_status);
	if (history->exit_status != orig_exit_status) {
	why = "degraded result";
	if (!expired && (!history->node->details->shutdown
	\|\| history->node->details->online)) {
	record_failed_op(history);
	}
	}

	if (!pcmk__is_bundled(history->rsc)
	&& pcmk_xe_mask_probe_failure(history->xml)
	&& ((history->execution_status != PCMK_EXEC_DONE)
	\|\| (history->exit_status != PCMK_OCF_NOT_RUNNING))) {
	history->execution_status = PCMK_EXEC_DONE;
	history->exit_status = PCMK_OCF_NOT_RUNNING;
	why = "equivalent probe result";
	}

	/* If the executor reported an execution status of anything but done or
	* error, consider that final. But for done or error, we know better whether
	* it should be treated as a failure or not, because we know the expected
	* result.
	*/
	switch (history->execution_status) {
	case PCMK_EXEC_DONE:
	case PCMK_EXEC_ERROR:
	break;

	// These should be treated as node-fatal
	case PCMK_EXEC_NO_FENCE_DEVICE:
	case PCMK_EXEC_NO_SECRETS:
	remap_because(history, &why, PCMK_EXEC_ERROR_HARD,
	"node-fatal error");
	goto remap_done;

	default:
	goto remap_done;
	}

	is_probe = pcmk_xe_is_probe(history->xml);
	if (is_probe) {
	task = "probe";
	}

	if (history->expected_exit_status < 0) {
	/* Pre-1.0 Pacemaker versions, and Pacemaker 1.1.6 or earlier with
	* Heartbeat 2.0.7 or earlier as the cluster layer, did not include the
	* expected exit status in the transition key, which (along with the
	* similar case of a corrupted transition key in the CIB) will be
	* reported to this function as -1. Pacemaker 2.0+ does not support
	* rolling upgrades from those versions or processing of saved CIB files
	* from those versions, so we do not need to care much about this case.
	*/
	remap_because(history, &why, PCMK_EXEC_ERROR,
	"obsolete history format");
	pcmk__config_warn("Expected result not found for %s on %s "
	"(corrupt or obsolete CIB?)",
	history->key, pcmk__node_name(history->node));

	} else if (history->exit_status == history->expected_exit_status) {
	remap_because(history, &why, PCMK_EXEC_DONE, "expected result");

	} else {
	remap_because(history, &why, PCMK_EXEC_ERROR, "unexpected result");
	pcmk__rsc_debug(history->rsc,
	"%s on %s: expected %d (%s), got %d (%s%s%s)",
	history->key, pcmk__node_name(history->node),
	history->expected_exit_status,
	services_ocf_exitcode_str(history->expected_exit_status),
	history->exit_status,
	services_ocf_exitcode_str(history->exit_status),
	(pcmk__str_empty(history->exit_reason)? "" : ": "),
	pcmk__s(history->exit_reason, ""));
	}

	switch (history->exit_status) {
	case PCMK_OCF_OK:
	if (is_probe
	&& (history->expected_exit_status == PCMK_OCF_NOT_RUNNING)) {
	char *last_change_s = last_change_str(history->xml);

	remap_because(history, &why, PCMK_EXEC_DONE, "probe");
	pcmk__rsc_info(history->rsc,
	"Probe found %s active on %s at %s",
	history->rsc->id, pcmk__node_name(history->node),
	last_change_s);
	free(last_change_s);
	}
	break;

	case PCMK_OCF_NOT_RUNNING:
	if (is_probe
	\|\| (history->expected_exit_status == history->exit_status)
	\|\| !pcmk_is_set(history->rsc->flags, pcmk__rsc_managed)) {

	/* For probes, recurring monitors for the Stopped role, and
	* unmanaged resources, "not running" is not considered a
	* failure.
	*/
	remap_because(history, &why, PCMK_EXEC_DONE, "exit status");
	history->rsc->private->orig_role = pcmk_role_stopped;
	*on_fail = pcmk__on_fail_ignore;
	pe__set_next_role(history->rsc, pcmk_role_unknown,
	"not running");
	}
	break;

	case PCMK_OCF_RUNNING_PROMOTED:
	if (is_probe
	&& (history->exit_status != history->expected_exit_status)) {
	char *last_change_s = last_change_str(history->xml);

	remap_because(history, &why, PCMK_EXEC_DONE, "probe");
	pcmk__rsc_info(history->rsc,
	"Probe found %s active and promoted on %s at %s",
	history->rsc->id,
	pcmk__node_name(history->node), last_change_s);
	free(last_change_s);
	}
	if (!expired
	\|\| (history->exit_status == history->expected_exit_status)) {
	history->rsc->private->orig_role = pcmk_role_promoted;
	}
	break;

	case PCMK_OCF_FAILED_PROMOTED:
	if (!expired) {
	history->rsc->private->orig_role = pcmk_role_promoted;
	}
	remap_because(history, &why, PCMK_EXEC_ERROR, "exit status");
	break;

	case PCMK_OCF_NOT_CONFIGURED:
	remap_because(history, &why, PCMK_EXEC_ERROR_FATAL, "exit status");
	break;

	case PCMK_OCF_UNIMPLEMENT_FEATURE:
	{
	guint interval_ms = 0;
	crm_element_value_ms(history->xml, PCMK_META_INTERVAL,
	&interval_ms);

	if (interval_ms == 0) {
	if (!expired) {
	block_if_unrecoverable(history);
	}
	remap_because(history, &why, PCMK_EXEC_ERROR_HARD,
	"exit status");
	} else {
	remap_because(history, &why, PCMK_EXEC_NOT_SUPPORTED,
	"exit status");
	}
	}
	break;

	case PCMK_OCF_NOT_INSTALLED:
	case PCMK_OCF_INVALID_PARAM:
	case PCMK_OCF_INSUFFICIENT_PRIV:
	if (!expired) {
	block_if_unrecoverable(history);
	}
	remap_because(history, &why, PCMK_EXEC_ERROR_HARD, "exit status");
	break;

	default:
	if (history->execution_status == PCMK_EXEC_DONE) {
	char *last_change_s = last_change_str(history->xml);

	crm_info("Treating unknown exit status %d from %s of %s "
	"on %s at %s as failure",
	history->exit_status, task, history->rsc->id,
	pcmk__node_name(history->node), last_change_s);
	remap_because(history, &why, PCMK_EXEC_ERROR,
	"unknown exit status");
	free(last_change_s);
	}
	break;
	}

	remap_done:
	if (why != NULL) {
	pcmk__rsc_trace(history->rsc,
	"Remapped %s result from [%s: %s] to [%s: %s] "
	"because of %s",
	history->key, pcmk_exec_status_str(orig_exec_status),
	crm_exit_str(orig_exit_status),
	pcmk_exec_status_str(history->execution_status),
	crm_exit_str(history->exit_status), why);
	}
	}

	// return TRUE if start or monitor last failure but parameters changed
	static bool
	should_clear_for_param_change(const xmlNode xml_op, const char task,
	pcmk_resource_t rsc, pcmk_node_t node)
	{
	if (pcmk__str_any_of(task, PCMK_ACTION_START, PCMK_ACTION_MONITOR, NULL)) {
	if (pe__bundle_needs_remote_name(rsc)) {
	/* We haven't allocated resources yet, so we can't reliably
	* substitute addr parameters for the REMOTE_CONTAINER_HACK.
	* When that's needed, defer the check until later.
	*/
	pe__add_param_check(xml_op, rsc, node, pcmk__check_last_failure,
	rsc->private->scheduler);

	} else {
	pcmk__op_digest_t *digest_data = NULL;

	digest_data = rsc_action_digest_cmp(rsc, xml_op, node,
	rsc->private->scheduler);
	switch (digest_data->rc) {
	case pcmk__digest_unknown:
	crm_trace("Resource %s history entry %s on %s"
	" has no digest to compare",
	rsc->id, pcmk__xe_history_key(xml_op),
	node->private->id);
	break;
	case pcmk__digest_match:
	break;
	default:
	return TRUE;
	}
	}
	}
	return FALSE;
	}

	// Order action after fencing of remote node, given connection rsc
	static void
	order_after_remote_fencing(pcmk_action_t action, pcmk_resource_t remote_conn,
	pcmk_scheduler_t *scheduler)
	{
	pcmk_node_t *remote_node = pcmk_find_node(scheduler, remote_conn->id);

	if (remote_node) {
	pcmk_action_t *fence = pe_fence_op(remote_node, NULL, TRUE, NULL,
	FALSE, scheduler);

	order_actions(fence, action, pcmk__ar_first_implies_then);
	}
	}

	static bool
	should_ignore_failure_timeout(const pcmk_resource_t rsc, const char task,
	guint interval_ms, bool is_last_failure)
	{
	/* Clearing failures of recurring monitors has special concerns. The
	* executor reports only changes in the monitor result, so if the
	* monitor is still active and still getting the same failure result,
	* that will go undetected after the failure is cleared.
	*
	* Also, the operation history will have the time when the recurring
	* monitor result changed to the given code, not the time when the
	* result last happened.
	*
	* @TODO We probably should clear such failures only when the failure
	* timeout has passed since the last occurrence of the failed result.
	* However we don't record that information. We could maybe approximate
	* that by clearing only if there is a more recent successful monitor or
	* stop result, but we don't even have that information at this point
	* since we are still unpacking the resource's operation history.
	*
	* This is especially important for remote connection resources with a
	* reconnect interval, so in that case, we skip clearing failures
	* if the remote node hasn't been fenced.
	*/
	if ((rsc->private->remote_reconnect_ms > 0U)
	&& pcmk_is_set(rsc->private->scheduler->flags,
	pcmk_sched_fencing_enabled)
	&& (interval_ms != 0)
	&& pcmk__str_eq(task, PCMK_ACTION_MONITOR, pcmk__str_casei)) {

	pcmk_node_t *remote_node = pcmk_find_node(rsc->private->scheduler,
	rsc->id);

	if (remote_node && !pcmk_is_set(remote_node->private->flags,
	pcmk__node_remote_fenced)) {
	if (is_last_failure) {
	crm_info("Waiting to clear monitor failure for remote node %s"
	" until fencing has occurred", rsc->id);
	}
	return TRUE;
	}
	}
	return FALSE;
	}

	/*!
	* \internal
	* \brief Check operation age and schedule failure clearing when appropriate
	*
	* This function has two distinct purposes. The first is to check whether an
	* operation history entry is expired (i.e. the resource has a failure timeout,
	* the entry is older than the timeout, and the resource either has no fail
	* count or its fail count is entirely older than the timeout). The second is to
	* schedule fail count clearing when appropriate (i.e. the operation is expired
	* and either the resource has an expired fail count or the operation is a
	* last_failure for a remote connection resource with a reconnect interval,
	* or the operation is a last_failure for a start or monitor operation and the
	* resource's parameters have changed since the operation).
	*
	* \param[in,out] history Parsed action result history
	*
	* \return true if operation history entry is expired, otherwise false
	*/
	static bool
	check_operation_expiry(struct action_history *history)
	{
	bool expired = false;
	bool is_last_failure = pcmk__ends_with(history->id, "_last_failure_0");
	time_t last_run = 0;
	int unexpired_fail_count = 0;
	const char *clear_reason = NULL;
	const guint expiration_sec =
	history->rsc->private->failure_expiration_ms / 1000;
	pcmk_scheduler_t *scheduler = history->rsc->private->scheduler;

	if (history->execution_status == PCMK_EXEC_NOT_INSTALLED) {
	pcmk__rsc_trace(history->rsc,
	"Resource history entry %s on %s is not expired: "
	"Not Installed does not expire",
	history->id, pcmk__node_name(history->node));
	return false; // "Not installed" must always be cleared manually
	}

	if ((expiration_sec > 0)
	&& (crm_element_value_epoch(history->xml, PCMK_XA_LAST_RC_CHANGE,
	&last_run) == 0)) {

	/* Resource has a PCMK_META_FAILURE_TIMEOUT and history entry has a
	* timestamp
	*/

	time_t now = get_effective_time(scheduler);
	time_t last_failure = 0;

	// Is this particular operation history older than the failure timeout?
	if ((now >= (last_run + expiration_sec))
	&& !should_ignore_failure_timeout(history->rsc, history->task,
	history->interval_ms,
	is_last_failure)) {
	expired = true;
	}

	// Does the resource as a whole have an unexpired fail count?
	unexpired_fail_count = pe_get_failcount(history->node, history->rsc,
	&last_failure,
	pcmk__fc_effective,
	history->xml);

	// Update scheduler recheck time according to last failure
	crm_trace("%s@%lld is %sexpired @%lld with unexpired_failures=%d "
	"expiration=%s last-failure@%lld",
	history->id, (long long) last_run, (expired? "" : "not "),
	(long long) now, unexpired_fail_count,
	pcmk__readable_interval(expiration_sec * 1000),
	(long long) last_failure);
	last_failure += expiration_sec + 1;
	if (unexpired_fail_count && (now < last_failure)) {
	pe__update_recheck_time(last_failure, scheduler,
	"fail count expiration");
	}
	}

	if (expired) {
	if (pe_get_failcount(history->node, history->rsc, NULL,
	pcmk__fc_default, history->xml)) {
	// There is a fail count ignoring timeout

	if (unexpired_fail_count == 0) {
	// There is no fail count considering timeout
	clear_reason = "it expired";

	} else {
	/* This operation is old, but there is an unexpired fail count.
	* In a properly functioning cluster, this should only be
	* possible if this operation is not a failure (otherwise the
	* fail count should be expired too), so this is really just a
	* failsafe.
	*/
	pcmk__rsc_trace(history->rsc,
	"Resource history entry %s on %s is not "
	"expired: Unexpired fail count",
	history->id, pcmk__node_name(history->node));
	expired = false;
	}

	} else if (is_last_failure
	&& (history->rsc->private->remote_reconnect_ms > 0U)) {
	/* Clear any expired last failure when reconnect interval is set,
	* even if there is no fail count.
	*/
	clear_reason = "reconnect interval is set";
	}
	}

	if (!expired && is_last_failure
	&& should_clear_for_param_change(history->xml, history->task,
	history->rsc, history->node)) {
	clear_reason = "resource parameters have changed";
	}

	if (clear_reason != NULL) {
	pcmk_action_t *clear_op = NULL;

	// Schedule clearing of the fail count
	clear_op = pe__clear_failcount(history->rsc, history->node,
	clear_reason, scheduler);

	if (pcmk_is_set(scheduler->flags, pcmk_sched_fencing_enabled)
	&& (history->rsc->private->remote_reconnect_ms > 0)) {
	/* If we're clearing a remote connection due to a reconnect
	* interval, we want to wait until any scheduled fencing
	* completes.
	*
	* We could limit this to remote_node->details->unclean, but at
	* this point, that's always true (it won't be reliable until
	* after unpack_node_history() is done).
	*/
	crm_info("Clearing %s failure will wait until any scheduled "
	"fencing of %s completes",
	history->task, history->rsc->id);
	order_after_remote_fencing(clear_op, history->rsc, scheduler);
	}
	}

	if (expired && (history->interval_ms == 0)
	&& pcmk__str_eq(history->task, PCMK_ACTION_MONITOR, pcmk__str_none)) {
	switch (history->exit_status) {
	case PCMK_OCF_OK:
	case PCMK_OCF_NOT_RUNNING:
	case PCMK_OCF_RUNNING_PROMOTED:
	case PCMK_OCF_DEGRADED:
	case PCMK_OCF_DEGRADED_PROMOTED:
	// Don't expire probes that return these values
	pcmk__rsc_trace(history->rsc,
	"Resource history entry %s on %s is not "
	"expired: Probe result",
	history->id, pcmk__node_name(history->node));
	expired = false;
	break;
	}
	}

	return expired;
	}

	int
	pe__target_rc_from_xml(const xmlNode *xml_op)
	{
	int target_rc = 0;
	const char *key = crm_element_value(xml_op, PCMK__XA_TRANSITION_KEY);

	if (key == NULL) {
	return -1;
	}
	decode_transition_key(key, NULL, NULL, NULL, &target_rc);
	return target_rc;
	}

	/*!
	* \internal
	* \brief Update a resource's state for an action result
	*
	* \param[in,out] history Parsed action history entry
	* \param[in] exit_status Exit status to base new state on
	* \param[in] last_failure Resource's last_failure entry, if known
	* \param[in,out] on_fail Resource's current failure handling
	*/
	static void
	update_resource_state(struct action_history *history, int exit_status,
	const xmlNode *last_failure,
	enum pcmk__on_fail *on_fail)
	{
	bool clear_past_failure = false;

	if ((exit_status == PCMK_OCF_NOT_INSTALLED)
	\|\| (!pcmk__is_bundled(history->rsc)
	&& pcmk_xe_mask_probe_failure(history->xml))) {
	history->rsc->private->orig_role = pcmk_role_stopped;

	} else if (exit_status == PCMK_OCF_NOT_RUNNING) {
	clear_past_failure = true;

	} else if (pcmk__str_eq(history->task, PCMK_ACTION_MONITOR,
	pcmk__str_none)) {
	if ((last_failure != NULL)
	&& pcmk__str_eq(history->key, pcmk__xe_history_key(last_failure),
	pcmk__str_none)) {
	clear_past_failure = true;
	}
	if (history->rsc->private->orig_role < pcmk_role_started) {
	set_active(history->rsc);
	}

	} else if (pcmk__str_eq(history->task, PCMK_ACTION_START, pcmk__str_none)) {
	history->rsc->private->orig_role = pcmk_role_started;
	clear_past_failure = true;

	} else if (pcmk__str_eq(history->task, PCMK_ACTION_STOP, pcmk__str_none)) {
	history->rsc->private->orig_role = pcmk_role_stopped;
	clear_past_failure = true;

	} else if (pcmk__str_eq(history->task, PCMK_ACTION_PROMOTE,
	pcmk__str_none)) {
	history->rsc->private->orig_role = pcmk_role_promoted;
	clear_past_failure = true;

	} else if (pcmk__str_eq(history->task, PCMK_ACTION_DEMOTE,
	pcmk__str_none)) {
	if (*on_fail == pcmk__on_fail_demote) {
	/* Demote clears an error only if
	* PCMK_META_ON_FAIL=PCMK_VALUE_DEMOTE
	*/
	clear_past_failure = true;
	}
	history->rsc->private->orig_role = pcmk_role_unpromoted;

	} else if (pcmk__str_eq(history->task, PCMK_ACTION_MIGRATE_FROM,
	pcmk__str_none)) {
	history->rsc->private->orig_role = pcmk_role_started;
	clear_past_failure = true;

	} else if (pcmk__str_eq(history->task, PCMK_ACTION_MIGRATE_TO,
	pcmk__str_none)) {
	unpack_migrate_to_success(history);

	} else if (history->rsc->private->orig_role < pcmk_role_started) {
	pcmk__rsc_trace(history->rsc, "%s active on %s",
	history->rsc->id, pcmk__node_name(history->node));
	set_active(history->rsc);
	}

	if (!clear_past_failure) {
	return;
	}

	switch (*on_fail) {
	case pcmk__on_fail_stop:
	case pcmk__on_fail_ban:
	case pcmk__on_fail_standby_node:
	case pcmk__on_fail_fence_node:
	pcmk__rsc_trace(history->rsc,
	"%s (%s) is not cleared by a completed %s",
	history->rsc->id, pcmk__on_fail_text(*on_fail),
	history->task);
	break;

	case pcmk__on_fail_block:
	case pcmk__on_fail_ignore:
	case pcmk__on_fail_demote:
	case pcmk__on_fail_restart:
	case pcmk__on_fail_restart_container:
	*on_fail = pcmk__on_fail_ignore;
	pe__set_next_role(history->rsc, pcmk_role_unknown,
	"clear past failures");
	break;

	case pcmk__on_fail_reset_remote:
	if (history->rsc->private->remote_reconnect_ms == 0U) {
	/* With no reconnect interval, the connection is allowed to
	* start again after the remote node is fenced and
	* completely stopped. (With a reconnect interval, we wait
	* for the failure to be cleared entirely before attempting
	* to reconnect.)
	*/
	*on_fail = pcmk__on_fail_ignore;
	pe__set_next_role(history->rsc, pcmk_role_unknown,
	"clear past failures and reset remote");
	}
	break;
	}
	}

	/*!
	* \internal
	* \brief Check whether a given history entry matters for resource state
	*
	* \param[in] history Parsed action history entry
	*
	* \return true if action can affect resource state, otherwise false
	*/
	static inline bool
	can_affect_state(struct action_history *history)
	{
	#if 0
	/* @COMPAT It might be better to parse only actions we know we're interested
	* in, rather than exclude a couple we don't. However that would be a
	* behavioral change that should be done at a major or minor series release.
	* Currently, unknown operations can affect whether a resource is considered
	* active and/or failed.
	*/
	return pcmk__str_any_of(history->task, PCMK_ACTION_MONITOR,
	PCMK_ACTION_START, PCMK_ACTION_STOP,
	PCMK_ACTION_PROMOTE, PCMK_ACTION_DEMOTE,
	PCMK_ACTION_MIGRATE_TO, PCMK_ACTION_MIGRATE_FROM,
	"asyncmon", NULL);
	#else
	return !pcmk__str_any_of(history->task, PCMK_ACTION_NOTIFY,
	PCMK_ACTION_META_DATA, NULL);
	#endif
	}

	/*!
	* \internal
	* \brief Unpack execution/exit status and exit reason from a history entry
	*
	* \param[in,out] history Action history entry to unpack
	*
	* \return Standard Pacemaker return code
	*/
	static int
	unpack_action_result(struct action_history *history)
	{
	if ((crm_element_value_int(history->xml, PCMK__XA_OP_STATUS,
	&(history->execution_status)) < 0)
	\|\| (history->execution_status < PCMK_EXEC_PENDING)
	\|\| (history->execution_status > PCMK_EXEC_MAX)
	\|\| (history->execution_status == PCMK_EXEC_CANCELLED)) {
	pcmk__config_err("Ignoring resource history entry %s for %s on %s "
	"with invalid " PCMK__XA_OP_STATUS " '%s'",
	history->id, history->rsc->id,
	pcmk__node_name(history->node),
	pcmk__s(crm_element_value(history->xml,
	PCMK__XA_OP_STATUS),
	""));
	return pcmk_rc_unpack_error;
	}
	if ((crm_element_value_int(history->xml, PCMK__XA_RC_CODE,
	&(history->exit_status)) < 0)
	\|\| (history->exit_status < 0) \|\| (history->exit_status > CRM_EX_MAX)) {
	#if 0
	/* @COMPAT We should ignore malformed entries, but since that would
	* change behavior, it should be done at a major or minor series
	* release.
	*/
	pcmk__config_err("Ignoring resource history entry %s for %s on %s "
	"with invalid " PCMK__XA_RC_CODE " '%s'",
	history->id, history->rsc->id,
	pcmk__node_name(history->node),
	pcmk__s(crm_element_value(history->xml,
	PCMK__XA_RC_CODE),
	""));
	return pcmk_rc_unpack_error;
	#else
	history->exit_status = CRM_EX_ERROR;
	#endif
	}
	history->exit_reason = crm_element_value(history->xml, PCMK_XA_EXIT_REASON);
	return pcmk_rc_ok;
	}

	/*!
	* \internal
	* \brief Process an action history entry whose result expired
	*
	* \param[in,out] history Parsed action history entry
	* \param[in] orig_exit_status Action exit status before remapping
	*
	* \return Standard Pacemaker return code (in particular, pcmk_rc_ok means the
	* entry needs no further processing)
	*/
	static int
	process_expired_result(struct action_history *history, int orig_exit_status)
	{
	if (!pcmk__is_bundled(history->rsc)
	&& pcmk_xe_mask_probe_failure(history->xml)
	&& (orig_exit_status != history->expected_exit_status)) {

	if (history->rsc->private->orig_role <= pcmk_role_stopped) {
	history->rsc->private->orig_role = pcmk_role_unknown;
	}
	crm_trace("Ignoring resource history entry %s for probe of %s on %s: "
	"Masked failure expired",
	history->id, history->rsc->id,
	pcmk__node_name(history->node));
	return pcmk_rc_ok;
	}

	if (history->exit_status == history->expected_exit_status) {
	return pcmk_rc_undetermined; // Only failures expire
	}

	if (history->interval_ms == 0) {
	crm_notice("Ignoring resource history entry %s for %s of %s on %s: "
	"Expired failure",
	history->id, history->task, history->rsc->id,
	pcmk__node_name(history->node));
	return pcmk_rc_ok;
	}

	if (history->node->details->online && !history->node->details->unclean) {
	/* Reschedule the recurring action. schedule_cancel() won't work at
	* this stage, so as a hacky workaround, forcibly change the restart
	* digest so pcmk__check_action_config() does what we want later.
	*
	* @TODO We should skip this if there is a newer successful monitor.
	* Also, this causes rescheduling only if the history entry
	* has a PCMK__XA_OP_DIGEST (which the expire-non-blocked-failure
	* scheduler regression test doesn't, but that may not be a
	* realistic scenario in production).
	*/
	crm_notice("Rescheduling %s-interval %s of %s on %s "
	"after failure expired",
	pcmk__readable_interval(history->interval_ms), history->task,
	history->rsc->id, pcmk__node_name(history->node));
	crm_xml_add(history->xml, PCMK__XA_OP_RESTART_DIGEST,
	"calculated-failure-timeout");
	return pcmk_rc_ok;
	}

	return pcmk_rc_undetermined;
	}

	/*!
	* \internal
	* \brief Process a masked probe failure
	*
	* \param[in,out] history Parsed action history entry
	* \param[in] orig_exit_status Action exit status before remapping
	* \param[in] last_failure Resource's last_failure entry, if known
	* \param[in,out] on_fail Resource's current failure handling
	*/
	static void
	mask_probe_failure(struct action_history *history, int orig_exit_status,
	const xmlNode *last_failure,
	enum pcmk__on_fail *on_fail)
	{
	pcmk_resource_t *ban_rsc = history->rsc;

	if (!pcmk_is_set(history->rsc->flags, pcmk__rsc_unique)) {
	ban_rsc = uber_parent(history->rsc);
	}

	crm_notice("Treating probe result '%s' for %s on %s as 'not running'",
	services_ocf_exitcode_str(orig_exit_status), history->rsc->id,
	pcmk__node_name(history->node));
	update_resource_state(history, history->expected_exit_status, last_failure,
	on_fail);
	crm_xml_add(history->xml, PCMK_XA_UNAME, history->node->private->name);

	record_failed_op(history);
	resource_location(ban_rsc, history->node, -PCMK_SCORE_INFINITY,
	"masked-probe-failure", ban_rsc->private->scheduler);
	}

	/*!
	* \internal Check whether a given failure is for a given pending action
	*
	* \param[in] history Parsed history entry for pending action
	* \param[in] last_failure Resource's last_failure entry, if known
	*
	* \return true if \p last_failure is failure of pending action in \p history,
	* otherwise false
	* \note Both \p history and \p last_failure must come from the same
	* \c PCMK__XE_LRM_RESOURCE block, as node and resource are assumed to be
	* the same.
	*/
	static bool
	failure_is_newer(const struct action_history *history,
	const xmlNode *last_failure)
	{
	guint failure_interval_ms = 0U;
	long long failure_change = 0LL;
	long long this_change = 0LL;

	if (last_failure == NULL) {
	return false; // Resource has no last_failure entry
	}

	if (!pcmk__str_eq(history->task,
	crm_element_value(last_failure, PCMK_XA_OPERATION),
	pcmk__str_none)) {
	return false; // last_failure is for different action
	}

	if ((crm_element_value_ms(last_failure, PCMK_META_INTERVAL,
	&failure_interval_ms) != pcmk_ok)
	\|\| (history->interval_ms != failure_interval_ms)) {
	return false; // last_failure is for action with different interval
	}

	if ((pcmk__scan_ll(crm_element_value(history->xml, PCMK_XA_LAST_RC_CHANGE),
	&this_change, 0LL) != pcmk_rc_ok)
	\|\| (pcmk__scan_ll(crm_element_value(last_failure,
	PCMK_XA_LAST_RC_CHANGE),
	&failure_change, 0LL) != pcmk_rc_ok)
	\|\| (failure_change < this_change)) {
	return false; // Failure is not known to be newer
	}

	return true;
	}

	/*!
	* \internal
	* \brief Update a resource's role etc. for a pending action
	*
	* \param[in,out] history Parsed history entry for pending action
	* \param[in] last_failure Resource's last_failure entry, if known
	*/
	static void
	process_pending_action(struct action_history *history,
	const xmlNode *last_failure)
	{
	/* For recurring monitors, a failure is recorded only in RSC_last_failure_0,
	* and there might be a RSC_monitor_INTERVAL entry with the last successful
	* or pending result.
	*
	* If last_failure contains the failure of the pending recurring monitor
	* we're processing here, and is newer, the action is no longer pending.
	* (Pending results have call ID -1, which sorts last, so the last failure
	* if any should be known.)
	*/
	if (failure_is_newer(history, last_failure)) {
	return;
	}

	if (strcmp(history->task, PCMK_ACTION_START) == 0) {
	pcmk__set_rsc_flags(history->rsc, pcmk__rsc_start_pending);
	set_active(history->rsc);

	} else if (strcmp(history->task, PCMK_ACTION_PROMOTE) == 0) {
	history->rsc->private->orig_role = pcmk_role_promoted;

	} else if ((strcmp(history->task, PCMK_ACTION_MIGRATE_TO) == 0)
	&& history->node->details->unclean) {
	/* A migrate_to action is pending on a unclean source, so force a stop
	* on the target.
	*/
	const char *migrate_target = NULL;
	pcmk_node_t *target = NULL;

	migrate_target = crm_element_value(history->xml,
	PCMK__META_MIGRATE_TARGET);
	target = pcmk_find_node(history->rsc->private->scheduler,
	migrate_target);
	if (target != NULL) {
	stop_action(history->rsc, target, FALSE);
	}
	}

	if (history->rsc->private->pending_action != NULL) {
	/* There should never be multiple pending actions, but as a failsafe,
	* just remember the first one processed for display purposes.
	*/
	return;
	}

	if (pcmk_is_probe(history->task, history->interval_ms)) {
	/* Pending probes are currently never displayed, even if pending
	* operations are requested. If we ever want to change that,
	* enable the below and the corresponding part of
	* native.c:native_pending_action().
	*/
	#if 0
	history->rsc->private->pending_action = strdup("probe");
	history->rsc->private->pending_node = history->node;
	#endif
	} else {
	history->rsc->private->pending_action = strdup(history->task);
	history->rsc->private->pending_node = history->node;
	}
	}

	static void
	unpack_rsc_op(pcmk_resource_t rsc, pcmk_node_t node, xmlNode *xml_op,
	xmlNode *last_failure, enum pcmk__on_fail on_fail)
	{
	int old_rc = 0;
	bool expired = false;
	pcmk_resource_t *parent = rsc;
	enum rsc_role_e fail_role = pcmk_role_unknown;
	enum pcmk__on_fail failure_strategy = pcmk__on_fail_restart;

	struct action_history history = {
	.rsc = rsc,
	.node = node,
	.xml = xml_op,
	.execution_status = PCMK_EXEC_UNKNOWN,
	};

	CRM_CHECK(rsc && node && xml_op, return);

	history.id = pcmk__xe_id(xml_op);
	if (history.id == NULL) {
	pcmk__config_err("Ignoring resource history entry for %s on %s "
	"without ID", rsc->id, pcmk__node_name(node));
	return;
	}

	// Task and interval
	history.task = crm_element_value(xml_op, PCMK_XA_OPERATION);
	if (history.task == NULL) {
	pcmk__config_err("Ignoring resource history entry %s for %s on %s "
	"without " PCMK_XA_OPERATION,
	history.id, rsc->id, pcmk__node_name(node));
	return;
	}
	crm_element_value_ms(xml_op, PCMK_META_INTERVAL, &(history.interval_ms));
	if (!can_affect_state(&history)) {
	pcmk__rsc_trace(rsc,
	"Ignoring resource history entry %s for %s on %s "
	"with irrelevant action '%s'",
	history.id, rsc->id, pcmk__node_name(node),
	history.task);
	return;
	}

	if (unpack_action_result(&history) != pcmk_rc_ok) {
	return; // Error already logged
	}

	history.expected_exit_status = pe__target_rc_from_xml(xml_op);
	history.key = pcmk__xe_history_key(xml_op);
	crm_element_value_int(xml_op, PCMK__XA_CALL_ID, &(history.call_id));

	pcmk__rsc_trace(rsc, "Unpacking %s (%s call %d on %s): %s (%s)",
	history.id, history.task, history.call_id,
	pcmk__node_name(node),
	pcmk_exec_status_str(history.execution_status),
	crm_exit_str(history.exit_status));

	if (node->details->unclean) {
	pcmk__rsc_trace(rsc,
	"%s is running on %s, which is unclean (further action "
	"depends on value of stop's on-fail attribute)",
	rsc->id, pcmk__node_name(node));
	}

	expired = check_operation_expiry(&history);
	old_rc = history.exit_status;

	remap_operation(&history, on_fail, expired);

	if (expired && (process_expired_result(&history, old_rc) == pcmk_rc_ok)) {
	goto done;
	}

	if (!pcmk__is_bundled(rsc) && pcmk_xe_mask_probe_failure(xml_op)) {
	mask_probe_failure(&history, old_rc, *last_failure, on_fail);
	goto done;
	}

	if (!pcmk_is_set(rsc->flags, pcmk__rsc_unique)) {
	parent = uber_parent(rsc);
	}

	switch (history.execution_status) {
	case PCMK_EXEC_PENDING:
	process_pending_action(&history, *last_failure);
	goto done;

	case PCMK_EXEC_DONE:
	update_resource_state(&history, history.exit_status, *last_failure,
	on_fail);
	goto done;

	case PCMK_EXEC_NOT_INSTALLED:
	unpack_failure_handling(&history, &failure_strategy, &fail_role);
	if (failure_strategy == pcmk__on_fail_ignore) {
	crm_warn("Cannot ignore failed %s of %s on %s: "
	"Resource agent doesn't exist "
	QB_XS " status=%d rc=%d id=%s",
	history.task, rsc->id, pcmk__node_name(node),
	history.execution_status, history.exit_status,
	history.id);
	/* Also for printing it as "FAILED" by marking it as
	* pcmk__rsc_failed later
	*/
	*on_fail = pcmk__on_fail_ban;
	}
	resource_location(parent, node, -PCMK_SCORE_INFINITY,
	"hard-error", rsc->private->scheduler);
	unpack_rsc_op_failure(&history, failure_strategy, fail_role,
	last_failure, on_fail);
	goto done;

	case PCMK_EXEC_NOT_CONNECTED:
	if (pcmk__is_pacemaker_remote_node(node)
	&& pcmk_is_set(node->private->remote->flags,
	pcmk__rsc_managed)) {
	/* We should never get into a situation where a managed remote
	* connection resource is considered OK but a resource action
	* behind the connection gets a "not connected" status. But as a
	* fail-safe in case a bug or unusual circumstances do lead to
	* that, ensure the remote connection is considered failed.
	*/
	pcmk__set_rsc_flags(node->private->remote,
	pcmk__rsc_failed\|pcmk__rsc_stop_if_failed);
	}
	break; // Not done, do error handling

	case PCMK_EXEC_ERROR:
	case PCMK_EXEC_ERROR_HARD:
	case PCMK_EXEC_ERROR_FATAL:
	case PCMK_EXEC_TIMEOUT:
	case PCMK_EXEC_NOT_SUPPORTED:
	case PCMK_EXEC_INVALID:
	break; // Not done, do error handling

	default: // No other value should be possible at this point
	break;
	}

	unpack_failure_handling(&history, &failure_strategy, &fail_role);
	if ((failure_strategy == pcmk__on_fail_ignore)
	\|\| ((failure_strategy == pcmk__on_fail_restart_container)
	&& (strcmp(history.task, PCMK_ACTION_STOP) == 0))) {

	char *last_change_s = last_change_str(xml_op);

	crm_warn("Pretending failed %s (%s%s%s) of %s on %s at %s succeeded "
	QB_XS " %s",
	history.task, services_ocf_exitcode_str(history.exit_status),
	(pcmk__str_empty(history.exit_reason)? "" : ": "),
	pcmk__s(history.exit_reason, ""), rsc->id,
	pcmk__node_name(node), last_change_s, history.id);
	free(last_change_s);

	update_resource_state(&history, history.expected_exit_status,
	*last_failure, on_fail);
	crm_xml_add(xml_op, PCMK_XA_UNAME, node->private->name);
	pcmk__set_rsc_flags(rsc, pcmk__rsc_ignore_failure);

	record_failed_op(&history);

	if ((failure_strategy == pcmk__on_fail_restart_container)
	&& (*on_fail <= pcmk__on_fail_restart)) {
	*on_fail = failure_strategy;
	}

	} else {
	unpack_rsc_op_failure(&history, failure_strategy, fail_role,
	last_failure, on_fail);

	if (history.execution_status == PCMK_EXEC_ERROR_HARD) {
	uint8_t log_level = LOG_ERR;

	if (history.exit_status == PCMK_OCF_NOT_INSTALLED) {
	log_level = LOG_NOTICE;
	}
	do_crm_log(log_level,
	"Preventing %s from restarting on %s because "
	"of hard failure (%s%s%s) " QB_XS " %s",
	parent->id, pcmk__node_name(node),
	services_ocf_exitcode_str(history.exit_status),
	(pcmk__str_empty(history.exit_reason)? "" : ": "),
	pcmk__s(history.exit_reason, ""), history.id);
	resource_location(parent, node, -PCMK_SCORE_INFINITY,
	"hard-error", rsc->private->scheduler);

	} else if (history.execution_status == PCMK_EXEC_ERROR_FATAL) {
	pcmk__sched_err("Preventing %s from restarting anywhere because "
	"of fatal failure (%s%s%s) " QB_XS " %s",
	parent->id,
	services_ocf_exitcode_str(history.exit_status),
	(pcmk__str_empty(history.exit_reason)? "" : ": "),
	pcmk__s(history.exit_reason, ""), history.id);
	resource_location(parent, NULL, -PCMK_SCORE_INFINITY,
	"fatal-error", rsc->private->scheduler);
	}
	}

	done:
	pcmk__rsc_trace(rsc, "%s role on %s after %s is %s (next %s)",
	rsc->id, pcmk__node_name(node), history.id,
	pcmk_role_text(rsc->private->orig_role),
	pcmk_role_text(rsc->private->next_role));
	}

	static void
	add_node_attrs(const xmlNode xml_obj, pcmk_node_t node, bool overwrite,
	pcmk_scheduler_t *scheduler)
	{
	const char *cluster_name = NULL;

	pe_rule_eval_data_t rule_data = {
	.node_hash = NULL,
	.now = scheduler->now,
	.match_data = NULL,
	.rsc_data = NULL,
	.op_data = NULL
	};

	pcmk__insert_dup(node->private->attrs,
	CRM_ATTR_UNAME, node->private->name);

	pcmk__insert_dup(node->private->attrs, CRM_ATTR_ID, node->private->id);
	if (pcmk__str_eq(node->private->id, scheduler->dc_uuid, pcmk__str_casei)) {
	scheduler->dc_node = node;
	pcmk__insert_dup(node->private->attrs,
	CRM_ATTR_IS_DC, PCMK_VALUE_TRUE);
	} else {
	pcmk__insert_dup(node->private->attrs,
	CRM_ATTR_IS_DC, PCMK_VALUE_FALSE);
	}

	cluster_name = g_hash_table_lookup(scheduler->config_hash,
	PCMK_OPT_CLUSTER_NAME);
	if (cluster_name) {
	pcmk__insert_dup(node->private->attrs, CRM_ATTR_CLUSTER_NAME,
	cluster_name);
	}

	pe__unpack_dataset_nvpairs(xml_obj, PCMK_XE_INSTANCE_ATTRIBUTES, &rule_data,
	node->private->attrs, NULL, overwrite,
	scheduler);

	pe__unpack_dataset_nvpairs(xml_obj, PCMK_XE_UTILIZATION, &rule_data,
	node->private->utilization, NULL,
	FALSE, scheduler);

	if (pcmk__node_attr(node, CRM_ATTR_SITE_NAME, NULL,
	pcmk__rsc_node_current) == NULL) {
	const char *site_name = pcmk__node_attr(node, "site-name", NULL,
	pcmk__rsc_node_current);

	if (site_name) {
	pcmk__insert_dup(node->private->attrs,
	CRM_ATTR_SITE_NAME, site_name);

	} else if (cluster_name) {
	/* Default to cluster-name if unset */
	pcmk__insert_dup(node->private->attrs,
	CRM_ATTR_SITE_NAME, cluster_name);
	}
	}
	}

	static GList *
	extract_operations(const char node, const char rsc, xmlNode * rsc_entry, gboolean active_filter)
	{
	int counter = -1;
	int stop_index = -1;
	int start_index = -1;

	xmlNode *rsc_op = NULL;

	GList *gIter = NULL;
	GList *op_list = NULL;
	GList *sorted_op_list = NULL;

	/* extract operations */
	op_list = NULL;
	sorted_op_list = NULL;

	for (rsc_op = pcmk__xe_first_child(rsc_entry, NULL, NULL, NULL);
	rsc_op != NULL; rsc_op = pcmk__xe_next(rsc_op)) {

	if (pcmk__xe_is(rsc_op, PCMK__XE_LRM_RSC_OP)) {
	crm_xml_add(rsc_op, PCMK_XA_RESOURCE, rsc);
	crm_xml_add(rsc_op, PCMK_XA_UNAME, node);
	op_list = g_list_prepend(op_list, rsc_op);
	}
	}

	if (op_list == NULL) {
	/* if there are no operations, there is nothing to do */
	return NULL;
	}

	sorted_op_list = g_list_sort(op_list, sort_op_by_callid);

	/* create active recurring operations as optional */
	if (active_filter == FALSE) {
	return sorted_op_list;
	}

	op_list = NULL;

	calculate_active_ops(sorted_op_list, &start_index, &stop_index);

	for (gIter = sorted_op_list; gIter != NULL; gIter = gIter->next) {
	xmlNode rsc_op = (xmlNode ) gIter->data;

	counter++;

	if (start_index < stop_index) {
	crm_trace("Skipping %s: not active", pcmk__xe_id(rsc_entry));
	break;

	} else if (counter < start_index) {
	crm_trace("Skipping %s: old", pcmk__xe_id(rsc_op));
	continue;
	}
	op_list = g_list_append(op_list, rsc_op);
	}

	g_list_free(sorted_op_list);
	return op_list;
	}

	GList *
	find_operations(const char rsc, const char node, gboolean active_filter,
	pcmk_scheduler_t *scheduler)
	{
	GList *output = NULL;
	GList *intermediate = NULL;

	xmlNode *tmp = NULL;
	xmlNode *status = pcmk__xe_first_child(scheduler->input, PCMK_XE_STATUS,
	NULL, NULL);

	pcmk_node_t *this_node = NULL;

	xmlNode *node_state = NULL;

	CRM_CHECK(status != NULL, return NULL);

	for (node_state = pcmk__xe_first_child(status, NULL, NULL, NULL);
	node_state != NULL; node_state = pcmk__xe_next(node_state)) {

	if (pcmk__xe_is(node_state, PCMK__XE_NODE_STATE)) {
	const char *uname = crm_element_value(node_state, PCMK_XA_UNAME);

	if (node != NULL && !pcmk__str_eq(uname, node, pcmk__str_casei)) {
	continue;
	}

	this_node = pcmk_find_node(scheduler, uname);
	if(this_node == NULL) {
	CRM_LOG_ASSERT(this_node != NULL);
	continue;

	} else if (pcmk__is_pacemaker_remote_node(this_node)) {
	determine_remote_online_status(scheduler, this_node);

	} else {
	determine_online_status(node_state, this_node, scheduler);
	}

	if (this_node->details->online
	\|\| pcmk_is_set(scheduler->flags, pcmk_sched_fencing_enabled)) {
	/* offline nodes run no resources...
	* unless stonith is enabled in which case we need to
	* make sure rsc start events happen after the stonith
	*/
	xmlNode *lrm_rsc = NULL;

	tmp = pcmk__xe_first_child(node_state, PCMK__XE_LRM, NULL,
	NULL);
	tmp = pcmk__xe_first_child(tmp, PCMK__XE_LRM_RESOURCES, NULL,
	NULL);

	for (lrm_rsc = pcmk__xe_first_child(tmp, NULL, NULL, NULL);
	lrm_rsc != NULL; lrm_rsc = pcmk__xe_next(lrm_rsc)) {

	if (pcmk__xe_is(lrm_rsc, PCMK__XE_LRM_RESOURCE)) {
	const char *rsc_id = crm_element_value(lrm_rsc,
	PCMK_XA_ID);

	if (rsc != NULL && !pcmk__str_eq(rsc_id, rsc, pcmk__str_casei)) {
	continue;
	}

	intermediate = extract_operations(uname, rsc_id, lrm_rsc, active_filter);
	output = g_list_concat(output, intermediate);
	}
	}
	}
	}
	}

	return output;
	}
	diff --git a/lib/pengine/utils.c b/lib/pengine/utils.c
	index 8e9ccd37ef..d798a49eb6 100644
	--- a/lib/pengine/utils.c
	+++ b/lib/pengine/utils.c
	@@ -1,907 +1,905 @@
	/*
	* Copyright 2004-2024 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.
	*/

	#include <crm_internal.h>

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

	#include <crm/crm.h>
	#include <crm/common/xml.h>
	#include <crm/pengine/rules.h>
	#include <crm/pengine/internal.h>

	#include "pe_status_private.h"

	extern bool pcmk__is_daemon;

	gboolean ghash_free_str_str(gpointer key, gpointer value, gpointer user_data);

	/*!
	* \internal
	* \brief Check whether we can fence a particular node
	*
	* \param[in] scheduler Scheduler data
	* \param[in] node Name of node to check
	*
	* \return true if node can be fenced, false otherwise
	*/
	bool
	pe_can_fence(const pcmk_scheduler_t scheduler, const pcmk_node_t node)
	{
	if (pcmk__is_guest_or_bundle_node(node)) {
	/* A guest or bundle node is fenced by stopping its launcher, which is
	* possible if the launcher's host is either online or fenceable.
	*/
	pcmk_resource_t *rsc = node->private->remote->private->launcher;

	for (GList *n = rsc->private->active_nodes; n != NULL; n = n->next) {
	pcmk_node_t *launcher_node = n->data;

	if (!launcher_node->details->online
	&& !pe_can_fence(scheduler, launcher_node)) {
	return false;
	}
	}
	return true;

	} else if (!pcmk_is_set(scheduler->flags, pcmk_sched_fencing_enabled)) {
	return false; /* Turned off */

	} else if (!pcmk_is_set(scheduler->flags, pcmk_sched_have_fencing)) {
	return false; /* No devices */

	} else if (pcmk_is_set(scheduler->flags, pcmk_sched_quorate)) {
	return true;

	} else if (scheduler->no_quorum_policy == pcmk_no_quorum_ignore) {
	return true;

	} else if(node == NULL) {
	return false;

	} else if(node->details->online) {
	crm_notice("We can fence %s without quorum because they're in our membership",
	pcmk__node_name(node));
	return true;
	}

	crm_trace("Cannot fence %s", pcmk__node_name(node));
	return false;
	}

	/*!
	* \internal
	* \brief Copy a node object
	*
	* \param[in] this_node Node object to copy
	*
	* \return Newly allocated shallow copy of this_node
	* \note This function asserts on errors and is guaranteed to return non-NULL.
	*/
	pcmk_node_t *
	pe__copy_node(const pcmk_node_t *this_node)
	{
	pcmk_node_t *new_node = NULL;

	CRM_ASSERT(this_node != NULL);

	new_node = pcmk__assert_alloc(1, sizeof(pcmk_node_t));
	new_node->assign = pcmk__assert_alloc(1,
	sizeof(struct pcmk__node_assignment));

	new_node->assign->probe_mode = this_node->assign->probe_mode;
	new_node->assign->score = this_node->assign->score;
	new_node->assign->count = this_node->assign->count;
	new_node->details = this_node->details;
	new_node->private = this_node->private;

	return new_node;
	}

	/*!
	* \internal
	* \brief Create a node hash table from a node list
	*
	* \param[in] list Node list
	*
	* \return Hash table equivalent of node list
	*/
	GHashTable *
	pe__node_list2table(const GList *list)
	{
	GHashTable *result = NULL;

	result = pcmk__strkey_table(NULL, free);
	for (const GList *gIter = list; gIter != NULL; gIter = gIter->next) {
	pcmk_node_t *new_node = NULL;

	new_node = pe__copy_node((const pcmk_node_t *) gIter->data);
	g_hash_table_insert(result, (gpointer) new_node->private->id, new_node);
	}
	return result;
	}

	/*!
	* \internal
	* \brief Compare two nodes by name, with numeric portions sorted numerically
	*
	* Sort two node names case-insensitively like strcasecmp(), but with any
	* numeric portions of the name sorted numerically. For example, "node10" will
	* sort higher than "node9" but lower than "remotenode9".
	*
	* \param[in] a First node to compare (can be \c NULL)
	* \param[in] b Second node to compare (can be \c NULL)
	*
	* \retval -1 \c a comes before \c b (or \c a is \c NULL and \c b is not)
	* \retval 0 \c a and \c b are equal (or both are \c NULL)
	* \retval 1 \c a comes after \c b (or \c b is \c NULL and \c a is not)
	*/
	gint
	pe__cmp_node_name(gconstpointer a, gconstpointer b)
	{
	const pcmk_node_t node1 = (const pcmk_node_t ) a;
	const pcmk_node_t node2 = (const pcmk_node_t ) b;

	if ((node1 == NULL) && (node2 == NULL)) {
	return 0;
	}

	if (node1 == NULL) {
	return -1;
	}

	if (node2 == NULL) {
	return 1;
	}

	return pcmk__numeric_strcasecmp(node1->private->name, node2->private->name);
	}

	/*!
	* \internal
	* \brief Output node weights to stdout
	*
	* \param[in] rsc Use allowed nodes for this resource
	* \param[in] comment Text description to prefix lines with
	* \param[in] nodes If rsc is not specified, use these nodes
	* \param[in,out] scheduler Scheduler data
	*/
	static void
	pe__output_node_weights(const pcmk_resource_t rsc, const char comment,
	GHashTable nodes, pcmk_scheduler_t scheduler)
	{
	pcmk__output_t *out = scheduler->priv;

	// Sort the nodes so the output is consistent for regression tests
	GList *list = g_list_sort(g_hash_table_get_values(nodes),
	pe__cmp_node_name);

	for (const GList *gIter = list; gIter != NULL; gIter = gIter->next) {
	const pcmk_node_t node = (const pcmk_node_t ) gIter->data;

	out->message(out, "node-weight", rsc, comment, node->private->name,
	pcmk_readable_score(node->assign->score));
	}
	g_list_free(list);
	}

	/*!
	* \internal
	* \brief Log node weights at trace level
	*
	* \param[in] file Caller's filename
	* \param[in] function Caller's function name
	* \param[in] line Caller's line number
	* \param[in] rsc If not NULL, include this resource's ID in logs
	* \param[in] comment Text description to prefix lines with
	* \param[in] nodes Nodes whose scores should be logged
	*/
	static void
	pe__log_node_weights(const char file, const char function, int line,
	const pcmk_resource_t rsc, const char comment,
	GHashTable *nodes)
	{
	GHashTableIter iter;
	pcmk_node_t *node = NULL;

	// Don't waste time if we're not tracing at this point
	pcmk__if_tracing({}, return);

	g_hash_table_iter_init(&iter, nodes);
	while (g_hash_table_iter_next(&iter, NULL, (void **) &node)) {
	if (rsc) {
	qb_log_from_external_source(function, file,
	"%s: %s allocation score on %s: %s",
	LOG_TRACE, line, 0,
	comment, rsc->id,
	pcmk__node_name(node),
	pcmk_readable_score(node->assign->score));
	} else {
	qb_log_from_external_source(function, file, "%s: %s = %s",
	LOG_TRACE, line, 0,
	comment, pcmk__node_name(node),
	pcmk_readable_score(node->assign->score));
	}
	}
	}

	/*!
	* \internal
	* \brief Log or output node weights
	*
	* \param[in] file Caller's filename
	* \param[in] function Caller's function name
	* \param[in] line Caller's line number
	* \param[in] to_log Log if true, otherwise output
	* \param[in] rsc If not NULL, use this resource's ID in logs,
	* and show scores recursively for any children
	* \param[in] comment Text description to prefix lines with
	* \param[in] nodes Nodes whose scores should be shown
	* \param[in,out] scheduler Scheduler data
	*/
	void
	pe__show_node_scores_as(const char file, const char function, int line,
	bool to_log, const pcmk_resource_t *rsc,
	const char comment, GHashTable nodes,
	pcmk_scheduler_t *scheduler)
	{
	if ((rsc != NULL) && pcmk_is_set(rsc->flags, pcmk__rsc_removed)) {
	// Don't show allocation scores for orphans
	return;
	}
	if (nodes == NULL) {
	// Nothing to show
	return;
	}

	if (to_log) {
	pe__log_node_weights(file, function, line, rsc, comment, nodes);
	} else {
	pe__output_node_weights(rsc, comment, nodes, scheduler);
	}

	if (rsc == NULL) {
	return;
	}

	// If this resource has children, repeat recursively for each
	for (GList *gIter = rsc->private->children;
	gIter != NULL; gIter = gIter->next) {

	pcmk_resource_t child = (pcmk_resource_t ) gIter->data;

	pe__show_node_scores_as(file, function, line, to_log, child, comment,
	child->private->allowed_nodes, scheduler);
	}
	}

	/*!
	* \internal
	* \brief Compare two resources by priority
	*
	* \param[in] a First resource to compare (can be \c NULL)
	* \param[in] b Second resource to compare (can be \c NULL)
	*
	* \retval -1 a's priority > b's priority (or \c b is \c NULL and \c a is not)
	* \retval 0 a's priority == b's priority (or both \c a and \c b are \c NULL)
	* \retval 1 a's priority < b's priority (or \c a is \c NULL and \c b is not)
	*/
	gint
	pe__cmp_rsc_priority(gconstpointer a, gconstpointer b)
	{
	const pcmk_resource_t resource1 = (const pcmk_resource_t )a;
	const pcmk_resource_t resource2 = (const pcmk_resource_t )b;

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

	if (resource1->private->priority > resource2->private->priority) {
	return -1;
	}

	if (resource1->private->priority < resource2->private->priority) {
	return 1;
	}

	return 0;
	}

	static void
	resource_node_score(pcmk_resource_t rsc, const pcmk_node_t node, int score,
	const char *tag)
	{
	pcmk_node_t *match = NULL;

	if ((pcmk_is_set(rsc->flags, pcmk__rsc_exclusive_probes)
	\|\| (node->assign->probe_mode == pcmk__probe_never))
	&& pcmk__str_eq(tag, "symmetric_default", pcmk__str_casei)) {
	/* This string comparision may be fragile, but exclusive resources and
	* exclusive nodes should not have the symmetric_default constraint
	* applied to them.
	*/
	return;

	} else {
	for (GList *gIter = rsc->private->children;
	gIter != NULL; gIter = gIter->next) {

	pcmk_resource_t child_rsc = (pcmk_resource_t ) gIter->data;

	resource_node_score(child_rsc, node, score, tag);
	}
	}

	match = g_hash_table_lookup(rsc->private->allowed_nodes, node->private->id);
	if (match == NULL) {
	match = pe__copy_node(node);
	g_hash_table_insert(rsc->private->allowed_nodes,
	(gpointer) match->private->id, match);
	}
	match->assign->score = pcmk__add_scores(match->assign->score, score);
	pcmk__rsc_trace(rsc,
	"Enabling %s preference (%s) for %s on %s (now %s)",
	tag, pcmk_readable_score(score), rsc->id,
	pcmk__node_name(node),
	pcmk_readable_score(match->assign->score));
	}

	void
	resource_location(pcmk_resource_t rsc, const pcmk_node_t node, int score,
	const char tag, pcmk_scheduler_t scheduler)
	{
	if (node != NULL) {
	resource_node_score(rsc, node, score, tag);

	} else if (scheduler != NULL) {
	GList *gIter = scheduler->nodes;

	for (; gIter != NULL; gIter = gIter->next) {
	pcmk_node_t node_iter = (pcmk_node_t ) gIter->data;

	resource_node_score(rsc, node_iter, score, tag);
	}

	} else {
	GHashTableIter iter;
	pcmk_node_t *node_iter = NULL;

	g_hash_table_iter_init(&iter, rsc->private->allowed_nodes);
	while (g_hash_table_iter_next(&iter, NULL, (void **)&node_iter)) {
	resource_node_score(rsc, node_iter, score, tag);
	}
	}

	if ((node == NULL) && (score == -PCMK_SCORE_INFINITY)
	&& (rsc->private->assigned_node != NULL)) {

	// @TODO Should this be more like pcmk__unassign_resource()?
	crm_info("Unassigning %s from %s",
	rsc->id, pcmk__node_name(rsc->private->assigned_node));
	free(rsc->private->assigned_node);
	rsc->private->assigned_node = NULL;
	}
	}

	time_t
	get_effective_time(pcmk_scheduler_t *scheduler)
	{
	if(scheduler) {
	if (scheduler->now == NULL) {
	crm_trace("Recording a new 'now'");
	scheduler->now = crm_time_new(NULL);
	}
	return crm_time_get_seconds_since_epoch(scheduler->now);
	}

	crm_trace("Defaulting to 'now'");
	return time(NULL);
	}

	gboolean
	get_target_role(const pcmk_resource_t rsc, enum rsc_role_e role)
	{
	enum rsc_role_e local_role = pcmk_role_unknown;
	const char *value = g_hash_table_lookup(rsc->private->meta,
	PCMK_META_TARGET_ROLE);

	CRM_CHECK(role != NULL, return FALSE);

	if (pcmk__str_eq(value, PCMK_ROLE_STARTED,
	pcmk__str_null_matches\|pcmk__str_casei)) {
	return FALSE;
	}
	if (pcmk__str_eq(PCMK_VALUE_DEFAULT, value, pcmk__str_casei)) {
	// @COMPAT Deprecated since 2.1.8
	pcmk__config_warn("Support for setting " PCMK_META_TARGET_ROLE
	" to the explicit value '" PCMK_VALUE_DEFAULT
	"' is deprecated and will be removed in a "
	"future release (just leave it unset)");
	return FALSE;
	}

	local_role = pcmk_parse_role(value);
	if (local_role == pcmk_role_unknown) {
	pcmk__config_err("Ignoring '" PCMK_META_TARGET_ROLE "' for %s "
	"because '%s' is not valid", rsc->id, value);
	return FALSE;

	} else if (local_role > pcmk_role_started) {
	if (pcmk_is_set(pe__const_top_resource(rsc, false)->flags,
	pcmk__rsc_promotable)) {
	if (local_role > pcmk_role_unpromoted) {
	/* This is what we'd do anyway, just leave the default to avoid messing up the placement algorithm */
	return FALSE;
	}

	} else {
	pcmk__config_err("Ignoring '" PCMK_META_TARGET_ROLE "' for %s "
	"because '%s' only makes sense for promotable "
	"clones", rsc->id, value);
	return FALSE;
	}
	}

	*role = local_role;
	return TRUE;
	}

	gboolean
	order_actions(pcmk_action_t lh_action, pcmk_action_t rh_action,
	uint32_t flags)
	{
	GList *gIter = NULL;
	pcmk__related_action_t *wrapper = NULL;
	GList *list = NULL;

	if (flags == pcmk__ar_none) {
	return FALSE;
	}

	if (lh_action == NULL \|\| rh_action == NULL) {
	return FALSE;
	}

	crm_trace("Creating action wrappers for ordering: %s then %s",
	lh_action->uuid, rh_action->uuid);

	/* Ensure we never create a dependency on ourselves... it's happened */
	CRM_ASSERT(lh_action != rh_action);

	/* Filter dups, otherwise update_action_states() has too much work to do */
	gIter = lh_action->actions_after;
	for (; gIter != NULL; gIter = gIter->next) {
	pcmk__related_action_t *after = gIter->data;

	if ((after->action == rh_action)
	&& pcmk_any_flags_set(after->flags, flags)) {
	return FALSE;
	}
	}

	wrapper = pcmk__assert_alloc(1, sizeof(pcmk__related_action_t));
	wrapper->action = rh_action;
	wrapper->flags = flags;
	list = lh_action->actions_after;
	list = g_list_prepend(list, wrapper);
	lh_action->actions_after = list;

	wrapper = pcmk__assert_alloc(1, sizeof(pcmk__related_action_t));
	wrapper->action = lh_action;
	wrapper->flags = flags;
	list = rh_action->actions_before;
	list = g_list_prepend(list, wrapper);
	rh_action->actions_before = list;
	return TRUE;
	}

	void
	destroy_ticket(gpointer data)
	{
	pcmk__ticket_t *ticket = data;

	if (ticket->state) {
	g_hash_table_destroy(ticket->state);
	}
	free(ticket->id);
	free(ticket);
	}

	pcmk__ticket_t *
	ticket_new(const char ticket_id, pcmk_scheduler_t scheduler)
	{
	pcmk__ticket_t *ticket = NULL;

	if (pcmk__str_empty(ticket_id)) {
	return NULL;
	}

	if (scheduler->tickets == NULL) {
	scheduler->tickets = pcmk__strkey_table(free, destroy_ticket);
	}

	ticket = g_hash_table_lookup(scheduler->tickets, ticket_id);
	if (ticket == NULL) {

	ticket = calloc(1, sizeof(pcmk__ticket_t));
	if (ticket == NULL) {
	pcmk__sched_err("Cannot allocate ticket '%s'", ticket_id);
	return NULL;
	}

	crm_trace("Creating ticket entry for %s", ticket_id);

	ticket->id = strdup(ticket_id);
	- ticket->granted = FALSE;
	ticket->last_granted = -1;
	- ticket->standby = FALSE;
	ticket->state = pcmk__strkey_table(free, free);

	g_hash_table_insert(scheduler->tickets, strdup(ticket->id), ticket);
	}

	return ticket;
	}

	const char *
	rsc_printable_id(const pcmk_resource_t *rsc)
	{
	if (pcmk_is_set(rsc->flags, pcmk__rsc_unique)) {
	return rsc->id;
	}
	return pcmk__xe_id(rsc->private->xml);
	}

	void
	pe__clear_resource_flags_recursive(pcmk_resource_t *rsc, uint64_t flags)
	{
	pcmk__clear_rsc_flags(rsc, flags);

	for (GList *gIter = rsc->private->children;
	gIter != NULL; gIter = gIter->next) {

	pe__clear_resource_flags_recursive((pcmk_resource_t *) gIter->data,
	flags);
	}
	}

	void
	pe__clear_resource_flags_on_all(pcmk_scheduler_t *scheduler, uint64_t flag)
	{
	for (GList *lpc = scheduler->resources; lpc != NULL; lpc = lpc->next) {
	pcmk_resource_t r = (pcmk_resource_t ) lpc->data;
	pe__clear_resource_flags_recursive(r, flag);
	}
	}

	void
	pe__set_resource_flags_recursive(pcmk_resource_t *rsc, uint64_t flags)
	{
	pcmk__set_rsc_flags(rsc, flags);

	for (GList *gIter = rsc->private->children;
	gIter != NULL; gIter = gIter->next) {

	pe__set_resource_flags_recursive((pcmk_resource_t *) gIter->data,
	flags);
	}
	}

	void
	trigger_unfencing(pcmk_resource_t rsc, pcmk_node_t node, const char *reason,
	pcmk_action_t dependency, pcmk_scheduler_t scheduler)
	{
	if (!pcmk_is_set(scheduler->flags, pcmk_sched_enable_unfencing)) {
	/* No resources require it */
	return;

	} else if ((rsc != NULL)
	&& !pcmk_is_set(rsc->flags, pcmk__rsc_fence_device)) {
	/* Wasn't a stonith device */
	return;

	} else if(node
	&& node->details->online
	&& node->details->unclean == FALSE
	&& node->details->shutdown == FALSE) {
	pcmk_action_t *unfence = pe_fence_op(node, PCMK_ACTION_ON, FALSE,
	reason, FALSE, scheduler);

	if(dependency) {
	order_actions(unfence, dependency, pcmk__ar_ordered);
	}

	} else if(rsc) {
	GHashTableIter iter;

	g_hash_table_iter_init(&iter, rsc->private->allowed_nodes);
	while (g_hash_table_iter_next(&iter, NULL, (void **)&node)) {
	if(node->details->online && node->details->unclean == FALSE && node->details->shutdown == FALSE) {
	trigger_unfencing(rsc, node, reason, dependency, scheduler);
	}
	}
	}
	}

	/*!
	* \internal
	* \brief Check whether shutdown has been requested for a node
	*
	* \param[in] node Node to check
	*
	* \return TRUE if node has shutdown attribute set and nonzero, FALSE otherwise
	* \note This differs from simply using node->details->shutdown in that it can
	* be used before that has been determined (and in fact to determine it),
	* and it can also be used to distinguish requested shutdown from implicit
	* shutdown of remote nodes by virtue of their connection stopping.
	*/
	bool
	pe__shutdown_requested(const pcmk_node_t *node)
	{
	const char *shutdown = pcmk__node_attr(node, PCMK__NODE_ATTR_SHUTDOWN, NULL,
	pcmk__rsc_node_current);

	return !pcmk__str_eq(shutdown, "0", pcmk__str_null_matches);
	}

	/*!
	* \internal
	* \brief Update "recheck by" time in scheduler data
	*
	* \param[in] recheck Epoch time when recheck should happen
	* \param[in,out] scheduler Scheduler data
	* \param[in] reason What time is being updated for (for logs)
	*/
	void
	pe__update_recheck_time(time_t recheck, pcmk_scheduler_t *scheduler,
	const char *reason)
	{
	if ((recheck > get_effective_time(scheduler))
	&& ((scheduler->recheck_by == 0)
	\|\| (scheduler->recheck_by > recheck))) {
	scheduler->recheck_by = recheck;
	crm_debug("Updated next scheduler recheck to %s for %s",
	pcmk__trim(ctime(&recheck)), reason);
	}
	}

	/*!
	* \internal
	* \brief Extract nvpair blocks contained by a CIB XML element into a hash table
	*
	* \param[in] xml_obj XML element containing blocks of nvpair elements
	* \param[in] set_name If not NULL, only use blocks of this element
	* \param[in] rule_data Matching parameters to use when unpacking
	* \param[out] hash Where to store extracted name/value pairs
	* \param[in] always_first If not NULL, process block with this ID first
	* \param[in] overwrite Whether to replace existing values with same name
	* \param[in,out] scheduler Scheduler data containing \p xml_obj
	*/
	void
	pe__unpack_dataset_nvpairs(const xmlNode xml_obj, const char set_name,
	const pe_rule_eval_data_t *rule_data,
	GHashTable hash, const char always_first,
	gboolean overwrite, pcmk_scheduler_t *scheduler)
	{
	crm_time_t *next_change = crm_time_new_undefined();

	pe_eval_nvpairs(scheduler->input, xml_obj, set_name, rule_data, hash,
	always_first, overwrite, next_change);
	if (crm_time_is_defined(next_change)) {
	time_t recheck = (time_t) crm_time_get_seconds_since_epoch(next_change);

	pe__update_recheck_time(recheck, scheduler, "rule evaluation");
	}
	crm_time_free(next_change);
	}

	bool
	pe__resource_is_disabled(const pcmk_resource_t *rsc)
	{
	const char *target_role = NULL;

	CRM_CHECK(rsc != NULL, return false);
	target_role = g_hash_table_lookup(rsc->private->meta,
	PCMK_META_TARGET_ROLE);
	if (target_role) {
	// If invalid, we've already logged an error when unpacking
	enum rsc_role_e target_role_e = pcmk_parse_role(target_role);

	if ((target_role_e == pcmk_role_stopped)
	\|\| ((target_role_e == pcmk_role_unpromoted)
	&& pcmk_is_set(pe__const_top_resource(rsc, false)->flags,
	pcmk__rsc_promotable))) {
	return true;
	}
	}
	return false;
	}

	/*!
	* \internal
	* \brief Check whether a resource is running only on given node
	*
	* \param[in] rsc Resource to check
	* \param[in] node Node to check
	*
	* \return true if \p rsc is running only on \p node, otherwise false
	*/
	bool
	pe__rsc_running_on_only(const pcmk_resource_t rsc, const pcmk_node_t node)
	{
	return (rsc != NULL) && pcmk__list_of_1(rsc->private->active_nodes)
	&& pcmk__same_node((const pcmk_node_t *)
	rsc->private->active_nodes->data, node);
	}

	bool
	pe__rsc_running_on_any(pcmk_resource_t rsc, GList node_list)
	{
	if (rsc != NULL) {
	for (GList *ele = rsc->private->active_nodes; ele; ele = ele->next) {
	pcmk_node_t node = (pcmk_node_t ) ele->data;
	if (pcmk__str_in_list(node->private->name, node_list,
	pcmk__str_star_matches\|pcmk__str_casei)) {
	return true;
	}
	}
	}
	return false;
	}

	bool
	pcmk__rsc_filtered_by_node(pcmk_resource_t rsc, GList only_node)
	{
	return rsc->private->fns->active(rsc, FALSE)
	&& !pe__rsc_running_on_any(rsc, only_node);
	}

	GList *
	pe__filter_rsc_list(GList rscs, GList filter)
	{
	GList *retval = NULL;

	for (GList *gIter = rscs; gIter; gIter = gIter->next) {
	pcmk_resource_t rsc = (pcmk_resource_t ) gIter->data;

	/* I think the second condition is safe here for all callers of this
	* function. If not, it needs to move into pe__node_text.
	*/
	if (pcmk__str_in_list(rsc_printable_id(rsc), filter, pcmk__str_star_matches) \|\|
	((rsc->private->parent != NULL)
	&& pcmk__str_in_list(rsc_printable_id(rsc->private->parent),
	filter, pcmk__str_star_matches))) {
	retval = g_list_prepend(retval, rsc);
	}
	}

	return retval;
	}

	GList *
	pe__build_node_name_list(pcmk_scheduler_t scheduler, const char s)
	{
	GList *nodes = NULL;

	if (pcmk__str_eq(s, "*", pcmk__str_null_matches)) {
	/* Nothing was given so return a list of all node names. Or, '*' was
	* given. This would normally fall into the pe__unames_with_tag branch
	* where it will return an empty list. Catch it here instead.
	*/
	nodes = g_list_prepend(nodes, strdup("*"));
	} else {
	pcmk_node_t *node = pcmk_find_node(scheduler, s);

	if (node) {
	/* The given string was a valid uname for a node. Return a
	* singleton list containing just that uname.
	*/
	nodes = g_list_prepend(nodes, strdup(s));
	} else {
	/* The given string was not a valid uname. It's either a tag or
	* it's a typo or something. In the first case, we'll return a
	* list of all the unames of the nodes with the given tag. In the
	* second case, we'll return a NULL pointer and nothing will
	* get displayed.
	*/
	nodes = pe__unames_with_tag(scheduler, s);
	}
	}

	return nodes;
	}

	GList *
	pe__build_rsc_list(pcmk_scheduler_t scheduler, const char s)
	{
	GList *resources = NULL;

	if (pcmk__str_eq(s, "*", pcmk__str_null_matches)) {
	resources = g_list_prepend(resources, strdup("*"));
	} else {
	const uint32_t flags = pcmk_rsc_match_history\|pcmk_rsc_match_basename;
	pcmk_resource_t *rsc = pe_find_resource_with_flags(scheduler->resources,
	s, flags);

	if (rsc) {
	/* A colon in the name we were given means we're being asked to filter
	* on a specific instance of a cloned resource. Put that exact string
	* into the filter list. Otherwise, use the printable ID of whatever
	* resource was found that matches what was asked for.
	*/
	if (strstr(s, ":") != NULL) {
	resources = g_list_prepend(resources, strdup(rsc->id));
	} else {
	resources = g_list_prepend(resources, strdup(rsc_printable_id(rsc)));
	}
	} else {
	/* The given string was not a valid resource name. It's a tag or a
	* typo or something. See pe__build_node_name_list() for more
	* detail.
	*/
	resources = pe__rscs_with_tag(scheduler, s);
	}
	}

	return resources;
	}

	xmlNode *
	pe__failed_probe_for_rsc(const pcmk_resource_t rsc, const char name)
	{
	const pcmk_resource_t *parent = pe__const_top_resource(rsc, false);
	const char *rsc_id = rsc->id;

	if (pcmk__is_clone(parent)) {
	rsc_id = pe__clone_child_id(parent);
	}

	for (xmlNode *xml_op = pcmk__xe_first_child(rsc->private->scheduler->failed,
	NULL, NULL, NULL);
	xml_op != NULL; xml_op = pcmk__xe_next(xml_op)) {

	const char *value = NULL;
	char *op_id = NULL;

	/* This resource operation is not a failed probe. */
	if (!pcmk_xe_mask_probe_failure(xml_op)) {
	continue;
	}

	/* This resource operation was not run on the given node. Note that if name is
	* NULL, this will always succeed.
	*/
	value = crm_element_value(xml_op, PCMK__META_ON_NODE);
	if (value == NULL \|\| !pcmk__str_eq(value, name, pcmk__str_casei\|pcmk__str_null_matches)) {
	continue;
	}

	if (!parse_op_key(pcmk__xe_history_key(xml_op), &op_id, NULL, NULL)) {
	continue; // This history entry is missing an operation key
	}

	/* This resource operation's ID does not match the rsc_id we are looking for. */
	if (!pcmk__str_eq(op_id, rsc_id, pcmk__str_none)) {
	free(op_id);
	continue;
	}

	free(op_id);
	return xml_op;
	}

	return NULL;
	}

File Metadata

Mime Type: text/x-diff
Expires: Wed, Jun 25, 3:21 AM (21 h, 15 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1951991
Default Alt Text: (391 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions