No OneTemporary
Actions

Size

290 KB

Referenced Files

None

Subscribers

None

View Options

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

	diff --git a/daemons/execd/cts-exec-helper.c b/daemons/execd/cts-exec-helper.c
	index 8c47e6ed7d..974794b1be 100644
	--- a/daemons/execd/cts-exec-helper.c
	+++ b/daemons/execd/cts-exec-helper.c
	@@ -1,626 +1,626 @@
	/*
	* Copyright 2012-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 <unistd.h>

	#include <crm/crm.h>
	#include <crm/services.h>
	#include <crm/common/cmdline_internal.h>
	#include <crm/common/mainloop.h>

	#include <crm/pengine/status.h>
	#include <crm/pengine/internal.h>
	#include <crm/cib.h>
	#include <crm/cib/internal.h>
	#include <crm/lrmd.h>

	#define SUMMARY "cts-exec-helper - inject commands into the Pacemaker executor and watch for events"

	static int exec_call_id = 0;
	static gboolean start_test(gpointer user_data);
	static void try_connect(void);

	static char *key = NULL;
	static char *val = NULL;

	static struct {
	int verbose;
	int quiet;
	guint interval_ms;
	int timeout;
	int start_delay;
	int cancel_call_id;
	gboolean no_wait;
	gboolean is_running;
	gboolean no_connect;
	int exec_call_opts;
	const char *api_call;
	const char *rsc_id;
	const char *provider;
	const char *class;
	const char *type;
	const char *action;
	const char *listen;
	gboolean use_tls;
	lrmd_key_value_t *params;
	} options;

	static gboolean
	interval_cb(const gchar option_name, const gchar optarg, gpointer data, GError **error) {
	return pcmk_parse_interval_spec(optarg,
	&options.interval_ms) == pcmk_rc_ok;
	}

	static gboolean
	notify_cb(const gchar option_name, const gchar optarg, gpointer data, GError **error) {
	if (pcmk__str_any_of(option_name, "--notify-orig", "-n", NULL)) {
	options.exec_call_opts = lrmd_opt_notify_orig_only;
	} else if (pcmk__str_any_of(option_name, "--notify-changes", "-o", NULL)) {
	options.exec_call_opts = lrmd_opt_notify_changes_only;
	}

	return TRUE;
	}

	static gboolean
	param_key_val_cb(const gchar option_name, const gchar optarg, gpointer data, GError **error) {
	if (pcmk__str_any_of(option_name, "--param-key", "-k", NULL)) {
	pcmk__str_update(&key, optarg);
	} else if (pcmk__str_any_of(option_name, "--param-val", "-v", NULL)) {
	pcmk__str_update(&val, optarg);
	}

	if (key != NULL && val != NULL) {
	options.params = lrmd_key_value_add(options.params, key, val);
	pcmk__str_update(&key, NULL);
	pcmk__str_update(&val, NULL);
	}

	return TRUE;
	}

	static GOptionEntry basic_entries[] = {
	{ "api-call", 'c', 0, G_OPTION_ARG_STRING, &options.api_call,
	"Directly relates to executor API functions",
	NULL },

	{ "is-running", 'R', 0, G_OPTION_ARG_NONE, &options.is_running,
	"Determine if a resource is registered and running",
	NULL },

	{ "listen", 'l', 0, G_OPTION_ARG_STRING, &options.listen,
	"Listen for a specific event string",
	NULL },

	{ "no-wait", 'w', 0, G_OPTION_ARG_NONE, &options.no_wait,
	"Make api call and do not wait for result",
	NULL },

	{ "notify-changes", 'o', G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, notify_cb,
	"Only notify client changes to recurring operations",
	NULL },

	{ "notify-orig", 'n', G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, notify_cb,
	"Only notify this client of the results of an API action",
	NULL },

	{ "tls", 'S', 0, G_OPTION_ARG_NONE, &options.use_tls,
	"Use TLS backend for local connection",
	NULL },

	{ NULL }
	};

	static GOptionEntry api_call_entries[] = {
	{ "action", 'a', 0, G_OPTION_ARG_STRING, &options.action,
	NULL, NULL },

	{ "cancel-call-id", 'x', 0, G_OPTION_ARG_INT, &options.cancel_call_id,
	NULL, NULL },

	{ "class", 'C', 0, G_OPTION_ARG_STRING, &options.class,
	NULL, NULL },

	{ "interval", 'i', 0, G_OPTION_ARG_CALLBACK, interval_cb,
	NULL, NULL },

	{ "param-key", 'k', 0, G_OPTION_ARG_CALLBACK, param_key_val_cb,
	NULL, NULL },

	{ "param-val", 'v', 0, G_OPTION_ARG_CALLBACK, param_key_val_cb,
	NULL, NULL },

	{ "provider", 'P', 0, G_OPTION_ARG_STRING, &options.provider,
	NULL, NULL },

	{ "rsc-id", 'r', 0, G_OPTION_ARG_STRING, &options.rsc_id,
	NULL, NULL },

	{ "start-delay", 's', 0, G_OPTION_ARG_INT, &options.start_delay,
	NULL, NULL },

	{ "timeout", 't', 0, G_OPTION_ARG_INT, &options.timeout,
	NULL, NULL },

	{ "type", 'T', 0, G_OPTION_ARG_STRING, &options.type,
	NULL, NULL },

	{ NULL }
	};

	static GMainLoop *mainloop = NULL;
	static lrmd_t *lrmd_conn = NULL;

	static char event_buf_v0[1024];

	static crm_exit_t
	test_exit(crm_exit_t exit_code)
	{
	lrmd_api_delete(lrmd_conn);
	return crm_exit(exit_code);
	}

	#define print_result(fmt, args...) \
	if (!options.quiet) { \
	printf(fmt "\n" , ##args); \
	}

	#define report_event(event) \
	snprintf(event_buf_v0, sizeof(event_buf_v0), "NEW_EVENT event_type:%s rsc_id:%s action:%s rc:%s op_status:%s", \
	lrmd_event_type2str(event->type), \
	event->rsc_id, \
	event->op_type ? event->op_type : "none", \
	services_ocf_exitcode_str(event->rc), \
	pcmk_exec_status_str(event->op_status)); \
	crm_info("%s", event_buf_v0);

	static void
	test_shutdown(int nsig)
	{
	lrmd_api_delete(lrmd_conn);
	lrmd_conn = NULL;
	}

	static void
	read_events(lrmd_event_data_t * event)
	{
	report_event(event);
	if (options.listen) {
	if (pcmk__str_eq(options.listen, event_buf_v0, pcmk__str_casei)) {
	print_result("LISTEN EVENT SUCCESSFUL");
	test_exit(CRM_EX_OK);
	}
	}

	if (exec_call_id && (event->call_id == exec_call_id)) {
	if (event->op_status == 0 && event->rc == 0) {
	print_result("API-CALL SUCCESSFUL for 'exec'");
	} else {
	print_result("API-CALL FAILURE for 'exec', rc:%d lrmd_op_status:%s",
	event->rc, pcmk_exec_status_str(event->op_status));
	test_exit(CRM_EX_ERROR);
	}

	if (!options.listen) {
	test_exit(CRM_EX_OK);
	}
	}
	}

	static gboolean
	timeout_err(gpointer data)
	{
	print_result("LISTEN EVENT FAILURE - timeout occurred, never found");
	test_exit(CRM_EX_TIMEOUT);
	return FALSE;
	}

	static void
	connection_events(lrmd_event_data_t * event)
	{
	int rc = event->connection_rc;

	if (event->type != lrmd_event_connect) {
	/* ignore */
	return;
	}

	if (!rc) {
	crm_info("Executor client connection established");
	start_test(NULL);
	return;
	} else {
	sleep(1);
	try_connect();
	crm_notice("Executor client connection failed");
	}
	}

	static void
	try_connect(void)
	{
	int tries = 10;
	static int num_tries = 0;
	int rc = 0;

	lrmd_conn->cmds->set_callback(lrmd_conn, connection_events);
	for (; num_tries < tries; num_tries++) {
	rc = lrmd_conn->cmds->connect_async(lrmd_conn, crm_system_name, 3000);

	if (!rc) {
	return; /* we'll hear back in async callback */
	}
	sleep(1);
	}

	print_result("API CONNECTION FAILURE");
	test_exit(CRM_EX_ERROR);
	}

	static gboolean
	start_test(gpointer user_data)
	{
	int rc = 0;

	if (!options.no_connect) {
	if (!lrmd_conn->cmds->is_connected(lrmd_conn)) {
	try_connect();
	/* async connect -- this function will get called back into */
	return 0;
	}
	}
	lrmd_conn->cmds->set_callback(lrmd_conn, read_events);

	if (options.timeout) {
	g_timeout_add(options.timeout, timeout_err, NULL);
	}

	if (!options.api_call) {
	return 0;
	}

	if (pcmk__str_eq(options.api_call, "exec", pcmk__str_casei)) {
	rc = lrmd_conn->cmds->exec(lrmd_conn,
	options.rsc_id,
	options.action,
	NULL,
	options.interval_ms,
	options.timeout,
	options.start_delay,
	options.exec_call_opts,
	options.params);

	if (rc > 0) {
	exec_call_id = rc;
	print_result("API-CALL 'exec' action pending, waiting on response");
	}

	} else if (pcmk__str_eq(options.api_call, "register_rsc", pcmk__str_casei)) {
	rc = lrmd_conn->cmds->register_rsc(lrmd_conn,
	options.rsc_id,
	options.class, options.provider, options.type, 0);
	} else if (pcmk__str_eq(options.api_call, "get_rsc_info", pcmk__str_casei)) {
	lrmd_rsc_info_t *rsc_info;

	rsc_info = lrmd_conn->cmds->get_rsc_info(lrmd_conn, options.rsc_id, 0);

	if (rsc_info) {
	print_result("RSC_INFO: id:%s class:%s provider:%s type:%s",
	rsc_info->id, rsc_info->standard,
	(rsc_info->provider? rsc_info->provider : "<none>"),
	rsc_info->type);
	lrmd_free_rsc_info(rsc_info);
	rc = pcmk_ok;
	} else {
	rc = -1;
	}
	} else if (pcmk__str_eq(options.api_call, "unregister_rsc", pcmk__str_casei)) {
	rc = lrmd_conn->cmds->unregister_rsc(lrmd_conn, options.rsc_id, 0);
	} else if (pcmk__str_eq(options.api_call, "cancel", pcmk__str_casei)) {
	rc = lrmd_conn->cmds->cancel(lrmd_conn, options.rsc_id, options.action,
	options.interval_ms);
	} else if (pcmk__str_eq(options.api_call, "metadata", pcmk__str_casei)) {
	char *output = NULL;

	rc = lrmd_conn->cmds->get_metadata(lrmd_conn,
	options.class,
	options.provider, options.type, &output, 0);
	if (rc == pcmk_ok) {
	print_result("%s", output);
	free(output);
	}
	} else if (pcmk__str_eq(options.api_call, "list_agents", pcmk__str_casei)) {
	lrmd_list_t *list = NULL;
	lrmd_list_t *iter = NULL;

	rc = lrmd_conn->cmds->list_agents(lrmd_conn, &list, options.class, options.provider);

	if (rc > 0) {
	print_result("%d agents found", rc);
	for (iter = list; iter != NULL; iter = iter->next) {
	print_result("%s", iter->val);
	}
	lrmd_list_freeall(list);
	rc = 0;
	} else {
	print_result("API_CALL FAILURE - no agents found");
	rc = -1;
	}
	} else if (pcmk__str_eq(options.api_call, "list_ocf_providers", pcmk__str_casei)) {
	lrmd_list_t *list = NULL;
	lrmd_list_t *iter = NULL;

	rc = lrmd_conn->cmds->list_ocf_providers(lrmd_conn, options.type, &list);

	if (rc > 0) {
	print_result("%d providers found", rc);
	for (iter = list; iter != NULL; iter = iter->next) {
	print_result("%s", iter->val);
	}
	lrmd_list_freeall(list);
	rc = 0;
	} else {
	print_result("API_CALL FAILURE - no providers found");
	rc = -1;
	}

	} else if (pcmk__str_eq(options.api_call, "list_standards", pcmk__str_casei)) {
	lrmd_list_t *list = NULL;
	lrmd_list_t *iter = NULL;

	rc = lrmd_conn->cmds->list_standards(lrmd_conn, &list);

	if (rc > 0) {
	print_result("%d standards found", rc);
	for (iter = list; iter != NULL; iter = iter->next) {
	print_result("%s", iter->val);
	}
	lrmd_list_freeall(list);
	rc = 0;
	} else {
	print_result("API_CALL FAILURE - no providers found");
	rc = -1;
	}

	} else if (pcmk__str_eq(options.api_call, "get_recurring_ops", pcmk__str_casei)) {
	GList *op_list = NULL;
	GList *op_item = NULL;
	rc = lrmd_conn->cmds->get_recurring_ops(lrmd_conn, options.rsc_id, 0, 0,
	&op_list);

	for (op_item = op_list; op_item != NULL; op_item = op_item->next) {
	lrmd_op_info_t *op_info = op_item->data;

	print_result("RECURRING_OP: %s_%s_%s timeout=%sms",
	op_info->rsc_id, op_info->action,
	op_info->interval_ms_s, op_info->timeout_ms_s);
	lrmd_free_op_info(op_info);
	}
	g_list_free(op_list);

	} else if (options.api_call) {
	print_result("API-CALL FAILURE unknown action '%s'", options.action);
	test_exit(CRM_EX_ERROR);
	}

	if (rc < 0) {
	print_result("API-CALL FAILURE for '%s' api_rc:%d",
	options.api_call, rc);
	test_exit(CRM_EX_ERROR);
	}

	if (options.api_call && rc == pcmk_ok) {
	print_result("API-CALL SUCCESSFUL for '%s'", options.api_call);
	if (!options.listen) {
	test_exit(CRM_EX_OK);
	}
	}

	if (options.no_wait) {
	/* just make the call and exit regardless of anything else. */
	test_exit(CRM_EX_OK);
	}

	return 0;
	}

	/*!
	* \internal
	* \brief Generate resource parameters from CIB if none explicitly given
	*
	* \return Standard Pacemaker return code
	*/
	static int
	generate_params(void)
	{
	int rc = pcmk_rc_ok;
	pcmk_scheduler_t *scheduler = NULL;
	xmlNode *cib_xml_copy = NULL;
	pcmk_resource_t *rsc = NULL;
	GHashTable *params = NULL;
	GHashTable *meta = NULL;
	GHashTableIter iter;
	char *key = NULL;
	char *value = NULL;

	if (options.params != NULL) {
	return pcmk_rc_ok; // User specified parameters explicitly
	}

	// Retrieve and update CIB
	rc = cib__signon_query(NULL, NULL, &cib_xml_copy);
	if (rc != pcmk_rc_ok) {
	return rc;
	}
	- rc = pcmk_update_configured_schema(&cib_xml_copy, false);
	+ rc = pcmk__update_configured_schema(&cib_xml_copy, false);
	if (rc != pcmk_rc_ok) {
	return rc;
	}

	// Calculate cluster status
	scheduler = pe_new_working_set();
	if (scheduler == NULL) {
	crm_crit("Could not allocate scheduler data");
	return ENOMEM;
	}
	pcmk__set_scheduler_flags(scheduler, pcmk__sched_no_counts);
	scheduler->input = cib_xml_copy;
	scheduler->priv->now = crm_time_new(NULL);
	cluster_status(scheduler);

	// Find resource in CIB
	rsc = pe_find_resource_with_flags(scheduler->priv->resources,
	options.rsc_id,
	pcmk_rsc_match_history
	\|pcmk_rsc_match_basename);
	if (rsc == NULL) {
	crm_err("Resource does not exist in config");
	pe_free_working_set(scheduler);
	return EINVAL;
	}

	// Add resource instance parameters to options.params
	params = pe_rsc_params(rsc, NULL, scheduler);
	if (params != NULL) {
	g_hash_table_iter_init(&iter, params);
	while (g_hash_table_iter_next(&iter, (gpointer *) &key,
	(gpointer *) &value)) {
	options.params = lrmd_key_value_add(options.params, key, value);
	}
	}

	// Add resource meta-attributes to options.params
	meta = pcmk__strkey_table(free, free);
	get_meta_attributes(meta, rsc, NULL, scheduler);
	g_hash_table_iter_init(&iter, meta);
	while (g_hash_table_iter_next(&iter, (gpointer *) &key,
	(gpointer *) &value)) {
	char *crm_name = crm_meta_name(key);

	options.params = lrmd_key_value_add(options.params, crm_name, value);
	free(crm_name);
	}
	g_hash_table_destroy(meta);

	pe_free_working_set(scheduler);
	return rc;
	}

	static GOptionContext *
	build_arg_context(pcmk__common_args_t args, GOptionGroup *group) {
	GOptionContext *context = NULL;

	context = pcmk__build_arg_context(args, NULL, group, NULL);

	pcmk__add_main_args(context, basic_entries);
	pcmk__add_arg_group(context, "api-call", "API Call Options:",
	"Parameters for api-call option", api_call_entries);

	return context;
	}

	int
	main(int argc, char **argv)
	{
	GError *error = NULL;
	crm_exit_t exit_code = CRM_EX_OK;
	crm_trigger_t *trig = NULL;

	pcmk__common_args_t *args = pcmk__new_common_args(SUMMARY);
	/* Typically we'd pass all the single character options that take an argument
	* as the second parameter here (and there's a bunch of those in this tool).
	* However, we control how this program is called so we can just not call it
	* in a way where the preprocessing ever matters.
	*/
	gchar **processed_args = pcmk__cmdline_preproc(argv, NULL);
	GOptionContext *context = build_arg_context(args, NULL);

	if (!g_option_context_parse_strv(context, &processed_args, &error)) {
	exit_code = CRM_EX_USAGE;
	goto done;
	}

	/* We have to use crm_log_init here to set up the logging because there's
	* different handling for daemons vs. command line programs, and
	* pcmk__cli_init_logging is set up to only handle the latter.
	*/
	crm_log_init(NULL, LOG_INFO, TRUE, (args->verbosity? TRUE : FALSE), argc,
	argv, FALSE);

	for (int i = 0; i < args->verbosity; i++) {
	crm_bump_log_level(argc, argv);
	}

	if (!options.listen && pcmk__strcase_any_of(options.api_call, "metadata", "list_agents",
	"list_standards", "list_ocf_providers", NULL)) {
	options.no_connect = TRUE;
	}

	if (options.is_running) {
	int rc = pcmk_rc_ok;

	if (options.rsc_id == NULL) {
	exit_code = CRM_EX_USAGE;
	g_set_error(&error, PCMK__EXITC_ERROR, exit_code,
	"--is-running requires --rsc-id");
	goto done;
	}

	options.interval_ms = 0;
	if (options.timeout == 0) {
	options.timeout = 30000;
	}

	rc = generate_params();
	if (rc != pcmk_rc_ok) {
	exit_code = pcmk_rc2exitc(rc);
	g_set_error(&error, PCMK__EXITC_ERROR, exit_code,
	"Can not determine resource status: "
	"unable to get parameters from CIB");
	goto done;
	}
	options.api_call = "exec";
	options.action = PCMK_ACTION_MONITOR;
	options.exec_call_opts = lrmd_opt_notify_orig_only;
	}

	if (!options.api_call && !options.listen) {
	exit_code = CRM_EX_USAGE;
	g_set_error(&error, PCMK__EXITC_ERROR, exit_code,
	"Must specify at least one of --api-call, --listen, "
	"or --is-running");
	goto done;
	}

	if (options.use_tls) {
	lrmd_conn = lrmd_remote_api_new(NULL, "localhost", 0);
	} else {
	lrmd_conn = lrmd_api_new();
	}
	trig = mainloop_add_trigger(G_PRIORITY_HIGH, start_test, NULL);
	mainloop_set_trigger(trig);
	mainloop_add_signal(SIGTERM, test_shutdown);

	crm_info("Starting");
	mainloop = g_main_loop_new(NULL, FALSE);
	g_main_loop_run(mainloop);

	done:
	g_strfreev(processed_args);
	pcmk__free_arg_context(context);

	free(key);
	free(val);

	pcmk__output_and_clear_error(&error, NULL);
	return test_exit(exit_code);
	}
	diff --git a/daemons/schedulerd/schedulerd_messages.c b/daemons/schedulerd/schedulerd_messages.c
	index 7ac180fcce..234a4395d0 100644
	--- a/daemons/schedulerd/schedulerd_messages.c
	+++ b/daemons/schedulerd/schedulerd_messages.c
	@@ -1,330 +1,330 @@
	/*
	* 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 <crm/crm.h>
	#include <crm/common/xml.h>
	#include <pacemaker-internal.h>

	#include <stdbool.h>
	#include <sys/stat.h>
	#include <sys/types.h>
	#include <unistd.h>

	#include "pacemaker-schedulerd.h"

	static GHashTable *schedulerd_handlers = NULL;

	static pcmk_scheduler_t *
	init_working_set(void)
	{
	pcmk_scheduler_t *scheduler = pe_new_working_set();

	pcmk__mem_assert(scheduler);
	scheduler->priv->out = logger_out;
	return scheduler;
	}

	static xmlNode *
	handle_pecalc_request(pcmk__request_t *request)
	{
	static struct series_s {
	const char *name;
	const char *param;

	/* Maximum number of inputs of this kind to save to disk.
	* If -1, save all; if 0, save none.
	*/
	int wrap;
	} series[] = {
	{ "pe-error", PCMK_OPT_PE_ERROR_SERIES_MAX, -1 },
	{ "pe-warn", PCMK_OPT_PE_WARN_SERIES_MAX, 5000 },
	{ "pe-input", PCMK_OPT_PE_INPUT_SERIES_MAX, 4000 },
	};

	xmlNode *msg = request->xml;
	xmlNode *wrapper = pcmk__xe_first_child(msg, PCMK__XE_CRM_XML, NULL, NULL);
	xmlNode *xml_data = pcmk__xe_first_child(wrapper, NULL, NULL, NULL);

	static char *last_digest = NULL;
	static char *filename = NULL;

	unsigned int seq;
	int series_id = 0;
	int series_wrap = 0;
	char *digest = NULL;
	const char *value = NULL;
	time_t execution_date = time(NULL);
	xmlNode *converted = NULL;
	xmlNode *reply = NULL;
	bool is_repoke = false;
	bool process = true;
	pcmk_scheduler_t *scheduler = init_working_set();

	pcmk__ipc_send_ack(request->ipc_client, request->ipc_id, request->ipc_flags,
	PCMK__XE_ACK, NULL, CRM_EX_INDETERMINATE);

	digest = pcmk__digest_xml(xml_data, false);
	converted = pcmk__xml_copy(NULL, xml_data);
	- if (pcmk_update_configured_schema(&converted, true) != pcmk_rc_ok) {
	+ if (pcmk__update_configured_schema(&converted, true) != pcmk_rc_ok) {
	scheduler->priv->graph = pcmk__xe_create(NULL,
	PCMK__XE_TRANSITION_GRAPH);
	crm_xml_add_int(scheduler->priv->graph, "transition_id", 0);
	crm_xml_add_int(scheduler->priv->graph, PCMK_OPT_CLUSTER_DELAY, 0);
	process = false;
	free(digest);

	} else if (pcmk__str_eq(digest, last_digest, pcmk__str_casei)) {
	is_repoke = true;
	free(digest);

	} else {
	free(last_digest);
	last_digest = digest;
	}

	if (process) {
	pcmk__schedule_actions(converted,
	pcmk__sched_no_counts
	\|pcmk__sched_show_utilization, scheduler);
	}

	// Get appropriate index into series[] array
	if (pcmk_is_set(scheduler->flags, pcmk__sched_processing_error)
	\|\| pcmk__config_has_error) {
	series_id = 0;
	} else if (pcmk_is_set(scheduler->flags, pcmk__sched_processing_warning)
	\|\| pcmk__config_has_warning) {
	series_id = 1;
	} else {
	series_id = 2;
	}

	value = pcmk__cluster_option(scheduler->priv->options,
	series[series_id].param);
	if ((value == NULL)
	\|\| (pcmk__scan_min_int(value, &series_wrap, -1) != pcmk_rc_ok)) {
	series_wrap = series[series_id].wrap;
	}

	if (pcmk__read_series_sequence(PE_STATE_DIR, series[series_id].name,
	&seq) != pcmk_rc_ok) {
	// @TODO maybe handle errors better ...
	seq = 0;
	}
	crm_trace("Series %s: wrap=%d, seq=%u, pref=%s",
	series[series_id].name, series_wrap, seq, value);

	scheduler->input = NULL;
	reply = pcmk__new_reply(msg, scheduler->priv->graph);

	if (reply == NULL) {
	pcmk__format_result(&request->result, CRM_EX_ERROR, PCMK_EXEC_ERROR,
	"Failed building ping reply for client %s",
	pcmk__client_name(request->ipc_client));
	goto done;
	}

	if (series_wrap == 0) { // Don't save any inputs of this kind
	free(filename);
	filename = NULL;

	} else if (!is_repoke) { // Input changed, save to disk
	free(filename);
	filename = pcmk__series_filename(PE_STATE_DIR,
	series[series_id].name, seq, true);
	}

	crm_xml_add(reply, PCMK__XA_CRM_TGRAPH_IN, filename);

	pcmk__log_transition_summary(scheduler, filename);

	if (series_wrap == 0) {
	crm_debug("Not saving input to disk (disabled by configuration)");

	} else if (is_repoke) {
	crm_info("Input has not changed since last time, not saving to disk");

	} else {
	unlink(filename);
	crm_xml_add_ll(xml_data, PCMK_XA_EXECUTION_DATE,
	(long long) execution_date);
	pcmk__xml_write_file(xml_data, filename, true);
	pcmk__write_series_sequence(PE_STATE_DIR, series[series_id].name,
	++seq, series_wrap);
	}

	pcmk__set_result(&request->result, CRM_EX_OK, PCMK_EXEC_DONE, NULL);

	done:
	pcmk__xml_free(converted);
	pe_free_working_set(scheduler);

	return reply;
	}

	static xmlNode *
	handle_unknown_request(pcmk__request_t *request)
	{
	pcmk__ipc_send_ack(request->ipc_client, request->ipc_id, request->ipc_flags,
	PCMK__XE_ACK, NULL, CRM_EX_INVALID_PARAM);

	pcmk__format_result(&request->result, CRM_EX_PROTOCOL, PCMK_EXEC_INVALID,
	"Unknown IPC request type '%s' (bug?)",
	pcmk__client_name(request->ipc_client));
	return NULL;
	}

	static xmlNode *
	handle_hello_request(pcmk__request_t *request)
	{
	pcmk__ipc_send_ack(request->ipc_client, request->ipc_id, request->ipc_flags,
	PCMK__XE_ACK, NULL, CRM_EX_INDETERMINATE);

	crm_trace("Received IPC hello from %s", pcmk__client_name(request->ipc_client));

	pcmk__set_result(&request->result, CRM_EX_OK, PCMK_EXEC_DONE, NULL);
	return NULL;
	}

	static void
	schedulerd_register_handlers(void)
	{
	pcmk__server_command_t handlers[] = {
	{ CRM_OP_HELLO, handle_hello_request },
	{ CRM_OP_PECALC, handle_pecalc_request },
	{ NULL, handle_unknown_request },
	};

	schedulerd_handlers = pcmk__register_handlers(handlers);
	}

	static int32_t
	pe_ipc_accept(qb_ipcs_connection_t * c, uid_t uid, gid_t gid)
	{
	crm_trace("Connection %p", c);
	if (pcmk__new_client(c, uid, gid) == NULL) {
	return -ENOMEM;
	}
	return 0;
	}

	static int32_t
	pe_ipc_dispatch(qb_ipcs_connection_t * qbc, void *data, size_t size)
	{
	uint32_t id = 0;
	uint32_t flags = 0;
	xmlNode *msg = NULL;
	pcmk__client_t *c = pcmk__find_client(qbc);
	const char *sys_to = NULL;

	CRM_CHECK(c != NULL, return 0);

	if (schedulerd_handlers == NULL) {
	schedulerd_register_handlers();
	}

	msg = pcmk__client_data2xml(c, data, &id, &flags);
	if (msg == NULL) {
	pcmk__ipc_send_ack(c, id, flags, PCMK__XE_ACK, NULL, CRM_EX_PROTOCOL);
	return 0;
	}

	sys_to = crm_element_value(msg, PCMK__XA_CRM_SYS_TO);

	if (pcmk__str_eq(crm_element_value(msg, PCMK__XA_SUBT),
	PCMK__VALUE_RESPONSE, pcmk__str_none)) {
	pcmk__ipc_send_ack(c, id, flags, PCMK__XE_ACK, NULL,
	CRM_EX_INDETERMINATE);
	crm_info("Ignoring IPC reply from %s", pcmk__client_name(c));

	} else if (!pcmk__str_eq(sys_to, CRM_SYSTEM_PENGINE, pcmk__str_none)) {
	pcmk__ipc_send_ack(c, id, flags, PCMK__XE_ACK, NULL,
	CRM_EX_INDETERMINATE);
	crm_info("Ignoring invalid IPC message: to '%s' not "
	CRM_SYSTEM_PENGINE, pcmk__s(sys_to, ""));

	} else {
	char *log_msg = NULL;
	const char *reason = NULL;
	xmlNode *reply = NULL;

	pcmk__request_t request = {
	.ipc_client = c,
	.ipc_id = id,
	.ipc_flags = flags,
	.peer = NULL,
	.xml = msg,
	.call_options = 0,
	.result = PCMK__UNKNOWN_RESULT,
	};

	request.op = crm_element_value_copy(request.xml, PCMK__XA_CRM_TASK);
	CRM_CHECK(request.op != NULL, return 0);

	reply = pcmk__process_request(&request, schedulerd_handlers);

	if (reply != NULL) {
	pcmk__ipc_send_xml(c, id, reply, crm_ipc_server_event);
	pcmk__xml_free(reply);
	}

	reason = request.result.exit_reason;

	log_msg = crm_strdup_printf("Processed %s request from %s %s: %s%s%s%s",
	request.op, pcmk__request_origin_type(&request),
	pcmk__request_origin(&request),
	pcmk_exec_status_str(request.result.execution_status),
	(reason == NULL)? "" : " (",
	(reason == NULL)? "" : reason,
	(reason == NULL)? "" : ")");

	if (!pcmk__result_ok(&request.result)) {
	crm_warn("%s", log_msg);
	} else {
	crm_debug("%s", log_msg);
	}

	free(log_msg);
	pcmk__reset_request(&request);
	}

	pcmk__xml_free(msg);
	return 0;
	}

	/* Error code means? */
	static int32_t
	pe_ipc_closed(qb_ipcs_connection_t * c)
	{
	pcmk__client_t *client = pcmk__find_client(c);

	if (client == NULL) {
	return 0;
	}
	crm_trace("Connection %p", c);
	pcmk__free_client(client);
	return 0;
	}

	static void
	pe_ipc_destroy(qb_ipcs_connection_t * c)
	{
	crm_trace("Connection %p", c);
	pe_ipc_closed(c);
	}

	struct qb_ipcs_service_handlers ipc_callbacks = {
	.connection_accept = pe_ipc_accept,
	.connection_created = NULL,
	.msg_process = pe_ipc_dispatch,
	.connection_closed = pe_ipc_closed,
	.connection_destroyed = pe_ipc_destroy
	};
	diff --git a/include/crm/common/schemas.h b/include/crm/common/schemas.h
	index 81fdc1933a..338311ba75 100644
	--- a/include/crm/common/schemas.h
	+++ b/include/crm/common/schemas.h
	@@ -1,32 +1,33 @@
	/*
	* 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 Lesser General Public License
	* version 2.1 or later (LGPLv2.1+) WITHOUT ANY WARRANTY.
	*/

	#ifndef PCMK__CRM_COMMON_SCHEMAS__H
	#define PCMK__CRM_COMMON_SCHEMAS__H

	#include <stdbool.h> // bool
	#include <libxml/tree.h> // xmlNode

	#ifdef __cplusplus
	extern "C" {
	#endif

	/*!
	* \file
	* \brief XML schema API
	* \ingroup core
	*/

	-int pcmk_update_configured_schema(xmlNode **xml, bool to_logs);
	+int
	+pcmk_update_configured_schema(xmlNode **xml);

	#ifdef __cplusplus
	}
	#endif

	#endif // PCMK__CRM_COMMON_SCHEMAS__H
	diff --git a/include/crm/common/schemas_internal.h b/include/crm/common/schemas_internal.h
	index adae4213e9..5936ed795e 100644
	--- a/include/crm/common/schemas_internal.h
	+++ b/include/crm/common/schemas_internal.h
	@@ -1,47 +1,49 @@
	/*
	* Copyright 2006-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_SCHEMAS_INTERNAL__H
	#define PCMK__CRM_COMMON_SCHEMAS_INTERNAL__H

	#include <stdbool.h>
	#include <glib.h> // GList, gboolean
	#include <libxml/relaxng.h> // xmlRelaxNGValidityErrorFunc
	#include <libxml/tree.h> // xmlNode

	#ifdef __cplusplus
	extern "C" {
	#endif

	void pcmk__schema_init(void);
	void pcmk__schema_cleanup(void);

	void pcmk__load_schemas_from_dir(const char *dir);
	void pcmk__sort_schemas(void);
	GList pcmk__schema_files_later_than(const char name);
	void pcmk__build_schema_xml_node(xmlNode parent, const char name,
	GList **already_included);
	const char *pcmk__remote_schema_dir(void);
	GList pcmk__get_schema(const char name);
	const char *pcmk__highest_schema_name(void);
	int pcmk__cmp_schemas_by_name(const char *schema1_name,
	const char *schema2_name);
	bool pcmk__validate_xml(xmlNode xml_blob, const char validation,
	xmlRelaxNGValidityErrorFunc error_handler,
	void *error_handler_context);
	bool pcmk__configured_schema_validates(xmlNode *xml);
	int pcmk__update_schema(xmlNode *xml, const char max_schema_name,
	bool transform, bool to_logs);
	void pcmk__warn_if_schema_deprecated(const char *schema);

	+int pcmk__update_configured_schema(xmlNode **xml, bool to_logs);
	+
	#ifdef __cplusplus
	}
	#endif

	#endif // PCMK__SCHEMAS_INTERNAL__H
	diff --git a/include/pacemaker.h b/include/pacemaker.h
	index c9fb326f28..ed52f8aa2d 100644
	--- a/include/pacemaker.h
	+++ b/include/pacemaker.h
	@@ -1,714 +1,715 @@
	/*
	* 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.
	*/

	#ifndef PCMK__PACEMAKER__H
	# define PCMK__PACEMAKER__H

	# include <glib.h>
	# include <libxml/tree.h>
	# include <crm/common/scheduler.h>
	# include <crm/cib/cib_types.h>

	# include <crm/stonith-ng.h>

	#ifdef __cplusplus
	extern "C" {
	#endif

	/**
	* \file
	* \brief High Level API
	* \ingroup pacemaker
	*/


	/*!
	* \brief Modify operation of running a cluster simulation.
	*/
	enum pcmk_sim_flags {
	pcmk_sim_none = 0,
	pcmk_sim_all_actions = 1 << 0,
	pcmk_sim_show_pending = 1 << 1,
	pcmk_sim_process = 1 << 2,
	pcmk_sim_show_scores = 1 << 3,
	pcmk_sim_show_utilization = 1 << 4,
	pcmk_sim_simulate = 1 << 5,
	pcmk_sim_sanitized = 1 << 6,
	pcmk_sim_verbose = 1 << 7,
	};

	/*!
	* \brief Synthetic cluster events that can be injected into the cluster
	* for running simulations.
	*/
	typedef struct {
	/! A list of node names (gchar ) to simulate bringing online */
	GList *node_up;
	/! A list of node names (gchar ) to simulate bringing offline */
	GList *node_down;
	/! A list of node names (gchar ) to simulate failing */
	GList *node_fail;
	/! A list of operations (gchar ) to inject. The format of these strings
	* is described in the "Operation Specification" section of crm_simulate
	* help output.
	*/
	GList *op_inject;
	/! A list of operations (gchar ) that should return a given error code
	* if they fail. The format of these strings is described in the
	* "Operation Specification" section of crm_simulate help output.
	*/
	GList *op_fail;
	/! A list of tickets (gchar ) to simulate granting */
	GList *ticket_grant;
	/! A list of tickets (gchar ) to simulate revoking */
	GList *ticket_revoke;
	/! A list of tickets (gchar ) to simulate putting on standby */
	GList *ticket_standby;
	/! A list of tickets (gchar ) to simulate activating */
	GList *ticket_activate;
	/! Does the cluster have an active watchdog device? /
	char *watchdog;
	/! Does the cluster have quorum? /
	char *quorum;
	} pcmk_injections_t;

	/*!
	* \brief Get and output controller status
	*
	* \param[in,out] xml Destination for the result, as an XML tree
	* \param[in] node_name Name of node whose status is desired
	* (\p NULL for DC)
	* \param[in] message_timeout_ms How long to wait for a reply from the
	* controller API. If 0,
	* \p pcmk_ipc_dispatch_sync will be used.
	* Otherwise, \p pcmk_ipc_dispatch_poll will
	* be used.
	*
	* \return Standard Pacemaker return code
	*/
	int pcmk_controller_status(xmlNodePtr xml, const char node_name,
	unsigned int message_timeout_ms);

	/*!
	* \brief Get and output designated controller node name
	*
	* \param[in,out] xml Destination for the result, as an XML tree
	* \param[in] message_timeout_ms How long to wait for a reply from the
	* controller API. If 0,
	* \p pcmk_ipc_dispatch_sync will be used.
	* Otherwise, \p pcmk_ipc_dispatch_poll will
	* be used.
	*
	* \return Standard Pacemaker return code
	*/
	int pcmk_designated_controller(xmlNodePtr *xml,
	unsigned int message_timeout_ms);

	/*!
	* \brief Free a :pcmk_injections_t structure
	*
	* \param[in,out] injections The structure to be freed
	*/
	void pcmk_free_injections(pcmk_injections_t *injections);

	/*!
	* \brief Get and optionally output node info corresponding to a node ID from
	* the controller
	*
	* \param[in,out] xml Destination for the result, as an XML tree
	* \param[in,out] node_id ID of node whose name to get. If \p NULL
	* or 0, get the local node name. If not
	* \p NULL, store the true node ID here on
	* success.
	* \param[out] node_name If not \p NULL, where to store the node
	* name
	* \param[out] uuid If not \p NULL, where to store the node
	* UUID
	* \param[out] state If not \p NULL, where to store the
	* membership state
	* \param[out] is_remote If not \p NULL, where to store whether the
	* node is a Pacemaker Remote node
	* \param[out] have_quorum If not \p NULL, where to store whether the
	* node has quorum
	* \param[in] show_output Whether to output the node info
	* \param[in] message_timeout_ms How long to wait for a reply from the
	* controller API. If 0,
	* \p pcmk_ipc_dispatch_sync will be used.
	* Otherwise, \p pcmk_ipc_dispatch_poll will
	* be used.
	*
	* \return Standard Pacemaker return code
	*
	* \note The caller is responsible for freeing \p node_name, \p uuid, and
	* \p *state using \p free().
	*/
	int pcmk_query_node_info(xmlNodePtr xml, uint32_t node_id, char **node_name,
	char uuid, char state, bool *have_quorum,
	bool *is_remote, bool show_output,
	unsigned int message_timeout_ms);

	/*!
	* \brief Get the node name corresponding to a node ID from the controller
	*
	* \param[in,out] xml Destination for the result, as an XML tree
	* \param[in,out] node_id ID of node whose name to get (or 0 for the
	* local node)
	* \param[out] node_name If not \p NULL, where to store the node
	* name
	* \param[in] message_timeout_ms How long to wait for a reply from the
	* controller API. If 0,
	* \p pcmk_ipc_dispatch_sync will be used.
	* Otherwise, \p pcmk_ipc_dispatch_poll will
	* be used.
	*
	* \return Standard Pacemaker return code
	*
	* \note The caller is responsible for freeing \p *node_name using \p free().
	*/
	static inline int
	pcmk_query_node_name(xmlNodePtr xml, uint32_t node_id, char *node_name,
	unsigned int message_timeout_ms)
	{
	return pcmk_query_node_info(xml, &node_id, node_name, NULL, NULL, NULL,
	NULL, false, message_timeout_ms);
	}

	/*!
	* \brief Get and output \p pacemakerd status
	*
	* \param[in,out] xml Destination for the result, as an XML tree
	* \param[in] ipc_name IPC name for request
	* \param[in] message_timeout_ms How long to wait for a reply from the
	* \p pacemakerd API. If 0,
	* \p pcmk_ipc_dispatch_sync will be used.
	* Otherwise, \p pcmk_ipc_dispatch_poll will
	* be used.
	*
	* \return Standard Pacemaker return code
	*/
	int pcmk_pacemakerd_status(xmlNodePtr xml, const char ipc_name,
	unsigned int message_timeout_ms);

	/*!
	* \brief Remove a resource
	*
	* \param[in,out] xml Destination for the result, as an XML tree
	* \param[in] rsc_id Resource to remove
	* \param[in] rsc_type Type of the resource ("primitive", "group", etc.)
	*
	* \return Standard Pacemaker return code
	* \note This function will return \p pcmk_rc_ok if \p rsc_id doesn't exist
	* or if \p rsc_type is incorrect for \p rsc_id (deleting something
	* that doesn't exist always succeeds).
	*/
	int pcmk_resource_delete(xmlNodePtr xml, const char rsc_id, const char *rsc_type);

	/*!
	* \brief Calculate and output resource operation digests
	*
	* \param[out] xml Where to store XML with result
	* \param[in,out] rsc Resource to calculate digests for
	* \param[in] node Node whose operation history should be used
	* \param[in] overrides Hash table of configuration parameters to override
	*
	* \return Standard Pacemaker return code
	*/
	int pcmk_resource_digests(xmlNodePtr xml, pcmk_resource_t rsc,
	const pcmk_node_t node, GHashTable overrides);

	/*!
	* \brief Simulate a cluster's response to events
	*
	* This high-level function essentially implements crm_simulate(8). It operates
	* on an input CIB file and various lists of events that can be simulated. It
	* optionally writes out a variety of artifacts to show the results of the
	* simulation. Output can be modified with various flags.
	*
	* \param[in,out] xml The destination for the result, as an XML tree
	* \param[in,out] scheduler Scheduler data
	* \param[in] injections A structure containing cluster events
	* (node up/down, tickets, injected operations)
	* \param[in] flags A bitfield of :pcmk_sim_flags to modify
	* operation of the simulation
	* \param[in] section_opts Which portions of the cluster status output
	* should be displayed?
	* \param[in] use_date Date to set the cluster's time to (may be NULL)
	* \param[in] input_file The source CIB file, which may be overwritten by
	* this function (may be NULL)
	* \param[in] graph_file Where to write the XML-formatted transition graph
	* (may be NULL, in which case no file will be
	* written)
	* \param[in] dot_file Where to write the dot(1) formatted transition
	* graph (may be NULL, in which case no file will
	* be written)
	*
	* \return Standard Pacemaker return code
	*/
	int pcmk_simulate(xmlNodePtr xml, pcmk_scheduler_t scheduler,
	const pcmk_injections_t *injections, unsigned int flags,
	unsigned int section_opts, const char *use_date,
	const char input_file, const char graph_file,
	const char *dot_file);

	/*!
	* \brief Verify that a CIB is error-free or output errors and warnings
	*
	* This high-level function essentially implements crm_verify(8). It operates
	* on an input CIB file, which can be inputted through one of several ways. It
	* writes out XML-formatted output.
	*
	* \param[in,out] xml The destination for the result, as an XML tree
	* \param[in] cib_source Source of the CIB:
	* NULL -> use live cib, "-" -> stdin
	* "<..." -> xml str, otherwise -> xml file name
	*
	* \return Standard Pacemaker return code
	*/
	int pcmk_verify(xmlNodePtr xml, const char cib_source);

	/*!
	* \brief Get nodes list
	*
	* \param[in,out] xml The destination for the result, as an XML tree
	* \param[in] node_types Node type(s) to return (default: all)
	*
	* \return Standard Pacemaker return code
	*/
	int pcmk_list_nodes(xmlNodePtr xml, const char node_types);

	/*!
	* \brief Output cluster status formatted like `crm_mon --output-as=xml`
	*
	* \param[in,out] xml The destination for the result, as an XML tree
	*
	* \return Standard Pacemaker return code
	*/
	int pcmk_status(xmlNodePtr *xml);

	/*!
	* \brief Check whether each rule in a list is in effect
	*
	* \param[in,out] xml The destination for the result, as an XML tree
	* \param[in] input The CIB XML to check (if \c NULL, use current CIB)
	* \param[in] date Check whether the rule is in effect at this date and
	* time (if \c NULL, use current date and time)
	* \param[in] rule_ids The IDs of the rules to check, as a <tt>NULL</tt>-
	* terminated list.
	*
	* \return Standard Pacemaker return code
	*/
	int pcmk_check_rules(xmlNodePtr xml, xmlNodePtr input, const crm_time_t date,
	const char **rule_ids);

	/*!
	* \brief Check whether a given rule is in effect
	*
	* \param[in,out] xml The destination for the result, as an XML tree
	* \param[in] input The CIB XML to check (if \c NULL, use current CIB)
	* \param[in] date Check whether the rule is in effect at this date and
	* time (if \c NULL, use current date and time)
	* \param[in] rule_ids The ID of the rule to check
	*
	* \return Standard Pacemaker return code
	*/
	static inline int
	pcmk_check_rule(xmlNodePtr xml, xmlNodePtr input, const crm_time_t date,
	const char *rule_id)
	{
	const char *rule_ids[] = {rule_id, NULL};
	return pcmk_check_rules(xml, input, date, rule_ids);
	}

	/*!
	* \enum pcmk_rc_disp_flags
	* \brief Bit flags to control which fields of result code info are displayed
	*/
	enum pcmk_rc_disp_flags {
	pcmk_rc_disp_none = 0, //!< (Does nothing)
	pcmk_rc_disp_code = (1 << 0), //!< Display result code number
	pcmk_rc_disp_name = (1 << 1), //!< Display result code name
	pcmk_rc_disp_desc = (1 << 2), //!< Display result code description
	};

	/*!
	* \brief Display the name and/or description of a result code
	*
	* \param[in,out] xml The destination for the result, as an XML tree
	* \param[in] code The result code
	* \param[in] type Interpret \c code as this type of result code.
	* Supported values: \c pcmk_result_legacy,
	* \c pcmk_result_rc, \c pcmk_result_exitcode.
	* \param[in] flags Group of \c pcmk_rc_disp_flags
	*
	* \return Standard Pacemaker return code
	*/
	int pcmk_show_result_code(xmlNodePtr *xml, int code, enum pcmk_result_type type,
	uint32_t flags);

	/*!
	* \brief List all valid result codes in a particular family
	*
	* \param[in,out] xml The destination for the result, as an XML tree
	* \param[in] type The family of result codes to list. Supported
	* values: \c pcmk_result_legacy, \c pcmk_result_rc,
	* \c pcmk_result_exitcode.
	* \param[in] flags Group of \c pcmk_rc_disp_flags
	*
	* \return Standard Pacemaker return code
	*/
	int pcmk_list_result_codes(xmlNodePtr *xml, enum pcmk_result_type type,
	uint32_t flags);

	/*!
	* \brief List available providers for the given OCF agent
	*
	* \param[in,out] xml The destination for the result, as an XML tree
	* \param[in] agent_spec Resource agent name
	*
	* \return Standard Pacemaker return code
	*/
	int pcmk_list_alternatives(xmlNodePtr xml, const char agent_spec);

	/*!
	* \brief List all agents available for the named standard and/or provider
	*
	* \param[in,out] xml The destination for the result, as an XML tree
	* \param[in] agent_spec STD[:PROV]
	*
	* \return Standard Pacemaker return code
	*/
	int pcmk_list_agents(xmlNodePtr xml, char agent_spec);

	/*!
	* \brief List all available OCF providers for the given agent
	*
	* \param[in,out] xml The destination for the result, as an XML tree
	* \param[in] agent_spec Resource agent name
	*
	* \return Standard Pacemaker return code
	*/
	int pcmk_list_providers(xmlNodePtr xml, const char agent_spec);

	/*!
	* \brief List all available resource agent standards
	*
	* \param[in,out] xml The destination for the result, as an XML tree
	*
	* \return Standard Pacemaker return code
	*/
	int pcmk_list_standards(xmlNodePtr *xml);

	/*!
	* \brief List all available cluster options
	*
	* These are options that affect the entire cluster.
	*
	* \param[in,out] xml The destination for the result, as an XML tree
	* \param[in] all If \c true, include advanced and deprecated options
	* (currently always treated as true)
	*
	* \return Standard Pacemaker return code
	*/
	int pcmk_list_cluster_options(xmlNode **xml, bool all);

	/*!
	* \brief List common fencing resource parameters
	*
	* These are parameters that are available for all fencing resources, regardless
	* of type. They are processed by Pacemaker, rather than by the fence agent or
	* the fencing library.
	*
	* \param[in,out] xml The destination for the result, as an XML tree
	* \param[in] all If \c true, include advanced and deprecated options
	* (currently always treated as true)
	*
	* \return Standard Pacemaker return code
	*/
	int pcmk_list_fencing_params(xmlNode **xml, bool all);

	/*!
	* \internal
	* \brief List meta-attributes applicable to primitive resources as OCF-like XML
	*
	* \param[in,out] out Output object
	* \param[in] all If \c true, include advanced and deprecated options (this
	* is always treated as true for XML output objects)
	*
	* \return Standard Pacemaker return code
	*/
	int pcmk_list_primitive_meta(xmlNode **xml, bool all);

	/*!
	* \brief Return constraints that apply to the given ticket
	*
	* \param[in,out] xml The destination for the result, as an XML tree
	* \param[in] ticket_id Ticket to find constraint for, or \c NULL for
	* all ticket constraints
	*
	* \return Standard Pacemaker return code
	*/
	int pcmk_ticket_constraints(xmlNodePtr xml, const char ticket_id);


	/*!
	* \brief Delete a ticket's state from the local cluster site
	*
	* \param[in,out] xml The destination for the result, as an XML tree
	* \param[in] ticket_id Ticket to delete
	* \param[in] force If \c true, delete the ticket even if it has
	* been granted
	*
	* \return Standard Pacemaker return code
	*/
	int pcmk_ticket_delete(xmlNodePtr xml, const char ticket_id, bool force);

	/*!
	* \brief Return the value of a ticket's attribute
	*
	* \param[in,out] xml The destination for the result, as an XML tree
	* \param[in] ticket_id Ticket to find attribute value for
	* \param[in] attr_name Attribute's name to find value for
	* \param[in] attr_default If either the ticket or the attribute do not
	* exist, use this as the value in \p xml
	*
	* \return Standard Pacemaker return code
	*/
	int pcmk_ticket_get_attr(xmlNodePtr xml, const char ticket_id,
	const char attr_name, const char attr_default);

	/*!
	* \brief Return information about the given ticket
	*
	* \param[in,out] xml The destination for the result, as an XML tree
	* \param[in] ticket_id Ticket to find info value for, or \c NULL for
	* all tickets
	*
	* \return Standard Pacemaker return code
	*/
	int pcmk_ticket_info(xmlNodePtr xml, const char ticket_id);

	/*!
	* \brief Remove the given attribute(s) from a ticket
	*
	* \param[in,out] xml The destination for the result, as an XML tree
	* \param[in] ticket_id Ticket to remove attributes from
	* \param[in] attr_delete A list of attribute names
	* \param[in] force Attempting to remove the granted attribute of
	* \p ticket_id will cause this function to return
	* \c EACCES unless \p force is set to \c true
	*
	* \return Standard Pacemaker return code
	*/
	int pcmk_ticket_remove_attr(xmlNodePtr xml, const char ticket_id, GList *attr_delete,
	bool force);

	/*!
	* \brief Set the given attribute(s) on a ticket
	*
	* \param[in,out] xml The destination for the result, as an XML tree
	* \param[in] ticket_id Ticket to set attributes on
	* \param[in] attr_set A hash table of attributes, where keys are the
	* attribute names and the values are the attribute
	* values
	* \param[in] force Attempting to change the granted status of
	* \p ticket_id will cause this function to return
	* \c EACCES unless \p force is set to \c true
	*
	* \return Standard Pacemaker return code
	*
	* \note If no \p ticket_id attribute exists but \p attr_set is non-NULL, the
	* ticket will be created with the given attributes.
	*/
	int pcmk_ticket_set_attr(xmlNodePtr xml, const char ticket_id, GHashTable *attr_set,
	bool force);

	/*!
	* \brief Return a ticket's state XML
	*
	* \param[in,out] xml The destination for the result, as an XML tree
	* \param[in] ticket_id Ticket to find state for, or \c NULL for all
	* tickets
	*
	* \return Standard Pacemaker return code
	*
	* \note If \p ticket_id is not \c NULL and more than one ticket exists with
	* that ID, this function returns \c pcmk_rc_duplicate_id.
	*/
	int pcmk_ticket_state(xmlNodePtr xml, const char ticket_id);

	#ifdef BUILD_PUBLIC_LIBPACEMAKER

	/*!
	* \brief Ask the cluster to perform fencing
	*
	* \param[in,out] st A connection to the fencer API
	* \param[in] target The node that should be fenced
	* \param[in] action The fencing action (on, off, reboot) to perform
	* \param[in] name Who requested the fence action?
	* \param[in] timeout How long to wait for operation to complete (in ms)
	* \param[in] tolerance If a successful action for \p target happened within
	* this many ms, return 0 without performing the action
	* again
	* \param[in] delay Apply this delay (in milliseconds) before initiating
	* fencing action (-1 applies no delay and also
	* disables any fencing delay from pcmk_delay_base and
	* pcmk_delay_max)
	* \param[out] reason If not NULL, where to put descriptive failure reason
	*
	* \return Standard Pacemaker return code
	* \note If \p reason is not NULL, the caller is responsible for freeing its
	* returned value.
	*/
	int pcmk_request_fencing(stonith_t st, const char target, const char *action,
	const char *name, unsigned int timeout,
	unsigned int tolerance, int delay, char **reason);

	/*!
	* \brief List the fencing operations that have occurred for a specific node
	*
	* \note If \p xml is not NULL, it will be freed first and the previous
	* contents lost.
	*
	* \param[in,out] xml The destination for the result, as an XML tree
	* \param[in,out] st A connection to the fencer API
	* \param[in] target The node to get history for
	* \param[in] timeout How long to wait for operation to complete (in ms)
	* \param[in] quiet Suppress most output
	* \param[in] verbose Include additional output
	* \param[in] broadcast Gather fencing history from all nodes
	* \param[in] cleanup Clean up fencing history after listing
	*
	* \return Standard Pacemaker return code
	*/
	int pcmk_fence_history(xmlNodePtr xml, stonith_t st, const char *target,
	unsigned int timeout, bool quiet, int verbose,
	bool broadcast, bool cleanup);

	/*!
	* \brief List all installed fence agents
	*
	* \param[in,out] xml The destination for the result, as an XML tree (if
	* not NULL, previous contents will be freed and lost)
	* \param[in,out] st A connection to the fencer API
	* \param[in] timeout How long to wait for operation to complete (in ms)
	*
	* \return Standard Pacemaker return code
	*/
	int pcmk_fence_installed(xmlNodePtr xml, stonith_t st, unsigned int timeout);

	/*!
	* \brief When was a device last fenced?
	*
	* \param[in,out] xml The destination for the result, as an XML tree (if
	* not NULL, previous contents will be freed and lost)
	* \param[in] target The node that was fenced
	* \param[in] as_nodeid If true, \p target has node ID rather than name
	*
	* \return Standard Pacemaker return code
	*/
	int pcmk_fence_last(xmlNodePtr xml, const char target, bool as_nodeid);

	/*!
	* \brief List nodes that can be fenced
	*
	* \param[in,out] xml The destination for the result, as an XML tree (if
	* not NULL, previous contents will be freed and lost)
	* \param[in,out] st A connection to the fencer API
	* \param[in] device_id Resource ID of fence device to check
	* \param[in] timeout How long to wait for operation to complete (in ms)
	*
	* \return Standard Pacemaker return code
	*/
	int pcmk_fence_list_targets(xmlNodePtr xml, stonith_t st,
	const char *device_id, unsigned int timeout);

	/*!
	* \brief Get metadata for a fence agent
	*
	* \note If \p xml is not NULL, it will be freed first and the previous
	* contents lost.
	*
	* \param[in,out] xml The destination for the result, as an XML tree (if
	* not NULL, previous contents will be freed and lost)
	* \param[in,out] st A connection to the fencer API
	* \param[in] agent The fence agent to get metadata for
	* \param[in] timeout How long to wait for operation to complete (in ms)
	*
	* \return Standard Pacemaker return code
	*/
	int pcmk_fence_metadata(xmlNodePtr xml, stonith_t st, const char *agent,
	unsigned int timeout);

	/*!
	* \brief List registered fence devices
	*
	* \param[in,out] xml The destination for the result, as an XML tree (if
	* not NULL, previous contents will be freed and lost)
	* \param[in,out] st A connection to the fencer API
	* \param[in] target If not NULL, return only devices that can fence this
	* \param[in] timeout How long to wait for operation to complete (in ms)
	*
	* \return Standard Pacemaker return code
	*/
	int pcmk_fence_registered(xmlNodePtr xml, stonith_t st, const char *target,
	unsigned int timeout);

	/*!
	* \brief Register a fencing topology level
	*
	* \param[in,out] st A connection to the fencer API
	* \param[in] target What fencing level targets (as "name=value" to
	* target by given node attribute, or "@pattern" to
	* target by node name pattern, or a node name)
	* \param[in] fence_level Index number of level to add
	* \param[in] devices Devices to use in level
	*
	* \return Standard Pacemaker return code
	*/
	int pcmk_fence_register_level(stonith_t st, const char target,
	int fence_level,
	const stonith_key_value_t *devices);

	/*!
	* \brief Unregister a fencing topology level
	*
	* \param[in,out] st A connection to the fencer API
	* \param[in] target What fencing level targets (as "name=value" to
	* target by given node attribute, or "@pattern" to
	* target by node name pattern, or a node name)
	* \param[in] fence_level Index number of level to remove
	*
	* \return Standard Pacemaker return code
	*/
	int pcmk_fence_unregister_level(stonith_t st, const char target,
	int fence_level);

	/*!
	* \brief Validate a fence device configuration
	*
	* \param[in,out] xml The destination for the result, as an XML tree (if
	* not NULL, previous contents will be freed and lost)
	* \param[in,out] st A connection to the fencer API
	* \param[in] agent The agent to validate (for example, "fence_xvm")
	* \param[in] id Fence device ID (may be NULL)
	* \param[in] params Fence device configuration parameters
	* \param[in] timeout How long to wait for operation to complete (in ms)
	*
	* \return Standard Pacemaker return code
	*/
	int pcmk_fence_validate(xmlNodePtr xml, stonith_t st, const char *agent,
	const char id, const stonith_key_value_t params,
	unsigned int timeout);
	+
	#endif

	#ifdef __cplusplus
	}
	#endif

	#endif
	diff --git a/lib/common/schemas.c b/lib/common/schemas.c
	index dc50f6e01f..0b379c7423 100644
	--- a/lib/common/schemas.c
	+++ b/lib/common/schemas.c
	@@ -1,1550 +1,1556 @@
	/*
	* 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 <dirent.h>
	#include <errno.h>
	#include <sys/stat.h>
	#include <stdarg.h>

	#include <libxml/relaxng.h>
	#include <libxslt/xslt.h>
	#include <libxslt/transform.h>
	#include <libxslt/security.h>
	#include <libxslt/xsltutils.h>

	#include <crm/common/xml.h>
	#include <crm/common/xml_internal.h> /* PCMK__XML_LOG_BASE */

	#include "crmcommon_private.h"

	#define SCHEMA_ZERO { .v = { 0, 0 } }

	#define schema_strdup_printf(prefix, version, suffix) \
	crm_strdup_printf(prefix "%u.%u" suffix, (version).v[0], (version).v[1])

	typedef struct {
	xmlRelaxNGPtr rng;
	xmlRelaxNGValidCtxtPtr valid;
	xmlRelaxNGParserCtxtPtr parser;
	} relaxng_ctx_cache_t;

	static GList *known_schemas = NULL;
	static bool initialized = false;
	static bool silent_logging = FALSE;

	static void G_GNUC_PRINTF(2, 3)
	xml_log(int priority, const char *fmt, ...)
	{
	va_list ap;

	va_start(ap, fmt);
	if (silent_logging == FALSE) {
	/* XXX should not this enable dechunking as well? */
	PCMK__XML_LOG_BASE(priority, FALSE, 0, NULL, fmt, ap);
	}
	va_end(ap);
	}

	static int
	xml_latest_schema_index(void)
	{
	/* This function assumes that pcmk__schema_init() has been called
	* beforehand, so we have at least three schemas (one real schema, the
	* "pacemaker-next" schema, and the "none" schema).
	*
	* @COMPAT: pacemaker-next is deprecated since 2.1.5 and none since 2.1.8.
	* Update this when we drop those.
	*/
	return g_list_length(known_schemas) - 3;
	}

	/*!
	* \internal
	* \brief Return the schema entry of the highest-versioned schema
	*
	* \return Schema entry of highest-versioned schema (or NULL on error)
	*/
	static GList *
	get_highest_schema(void)
	{
	/* The highest numerically versioned schema is the one before pacemaker-next
	*
	* @COMPAT pacemaker-next is deprecated since 2.1.5
	*/
	GList *entry = pcmk__get_schema("pacemaker-next");

	CRM_ASSERT((entry != NULL) && (entry->prev != NULL));
	return entry->prev;
	}

	/*!
	* \internal
	* \brief Return the name of the highest-versioned schema
	*
	* \return Name of highest-versioned schema (or NULL on error)
	*/
	const char *
	pcmk__highest_schema_name(void)
	{
	GList *entry = get_highest_schema();

	return ((pcmk__schema_t *)(entry->data))->name;
	}

	/*!
	* \internal
	* \brief Find first entry of highest major schema version series
	*
	* \return Schema entry of first schema with highest major version
	*/
	GList *
	pcmk__find_x_0_schema(void)
	{
	#if defined(PCMK__UNIT_TESTING)
	/* If we're unit testing, this can't be static because it'll stick
	* around from one test run to the next. It needs to be cleared out
	* every time.
	*/
	GList *x_0_entry = NULL;
	#else
	static GList *x_0_entry = NULL;
	#endif

	pcmk__schema_t *highest_schema = NULL;

	if (x_0_entry != NULL) {
	return x_0_entry;
	}
	x_0_entry = get_highest_schema();
	highest_schema = x_0_entry->data;

	for (GList *iter = x_0_entry->prev; iter != NULL; iter = iter->prev) {
	pcmk__schema_t *schema = iter->data;

	/* We've found a schema in an older major version series. Return
	* the index of the first one in the same major version series as
	* the highest schema.
	*/
	if (schema->version.v[0] < highest_schema->version.v[0]) {
	x_0_entry = iter->next;
	break;
	}

	/* We're out of list to examine. This probably means there was only
	* one major version series, so return the first schema entry.
	*/
	if (iter->prev == NULL) {
	x_0_entry = known_schemas->data;
	break;
	}
	}
	return x_0_entry;
	}

	static inline bool
	version_from_filename(const char filename, pcmk__schema_version_t version)
	{
	if (pcmk__ends_with(filename, ".rng")) {
	return sscanf(filename, "pacemaker-%hhu.%hhu.rng", &(version->v[0]), &(version->v[1])) == 2;
	} else {
	return sscanf(filename, "pacemaker-%hhu.%hhu", &(version->v[0]), &(version->v[1])) == 2;
	}
	}

	static int
	schema_filter(const struct dirent *a)
	{
	int rc = 0;
	pcmk__schema_version_t version = SCHEMA_ZERO;

	if (strstr(a->d_name, "pacemaker-") != a->d_name) {
	/* crm_trace("%s - wrong prefix", a->d_name); */

	} else if (!pcmk__ends_with_ext(a->d_name, ".rng")) {
	/* crm_trace("%s - wrong suffix", a->d_name); */

	} else if (!version_from_filename(a->d_name, &version)) {
	/* crm_trace("%s - wrong format", a->d_name); */

	} else {
	/* crm_debug("%s - candidate", a->d_name); */
	rc = 1;
	}

	return rc;
	}

	static int
	schema_cmp(pcmk__schema_version_t a_version, pcmk__schema_version_t b_version)
	{
	for (int i = 0; i < 2; ++i) {
	if (a_version.v[i] < b_version.v[i]) {
	return -1;
	} else if (a_version.v[i] > b_version.v[i]) {
	return 1;
	}
	}
	return 0;
	}

	static int
	schema_cmp_directory(const struct dirent a, const struct dirent b)
	{
	pcmk__schema_version_t a_version = SCHEMA_ZERO;
	pcmk__schema_version_t b_version = SCHEMA_ZERO;

	if (!version_from_filename(a[0]->d_name, &a_version)
	\|\| !version_from_filename(b[0]->d_name, &b_version)) {
	// Shouldn't be possible, but makes static analysis happy
	return 0;
	}

	return schema_cmp(a_version, b_version);
	}

	/*!
	* \internal
	* \brief Add given schema + auxiliary data to internal bookkeeping.
	*/
	static void
	add_schema(enum pcmk__schema_validator validator,
	const pcmk__schema_version_t version, const char name,
	GList *transforms)
	{
	pcmk__schema_t *schema = NULL;

	schema = pcmk__assert_alloc(1, sizeof(pcmk__schema_t));

	schema->validator = validator;
	schema->version.v[0] = version->v[0];
	schema->version.v[1] = version->v[1];
	schema->transforms = transforms;
	// schema->schema_index is set after all schemas are loaded and sorted

	if (version->v[0] \|\| version->v[1]) {
	schema->name = schema_strdup_printf("pacemaker-", *version, "");
	} else {
	schema->name = pcmk__str_copy(name);
	}

	known_schemas = g_list_prepend(known_schemas, schema);
	}

	static void
	wrap_libxslt(bool finalize)
	{
	static xsltSecurityPrefsPtr secprefs;
	int ret = 0;

	/* security framework preferences */
	if (!finalize) {
	CRM_ASSERT(secprefs == NULL);
	secprefs = xsltNewSecurityPrefs();
	ret = xsltSetSecurityPrefs(secprefs, XSLT_SECPREF_WRITE_FILE,
	xsltSecurityForbid)
	\| xsltSetSecurityPrefs(secprefs, XSLT_SECPREF_CREATE_DIRECTORY,
	xsltSecurityForbid)
	\| xsltSetSecurityPrefs(secprefs, XSLT_SECPREF_READ_NETWORK,
	xsltSecurityForbid)
	\| xsltSetSecurityPrefs(secprefs, XSLT_SECPREF_WRITE_NETWORK,
	xsltSecurityForbid);
	if (ret != 0) {
	return;
	}
	} else {
	xsltFreeSecurityPrefs(secprefs);
	secprefs = NULL;
	}

	/* cleanup only */
	if (finalize) {
	xsltCleanupGlobals();
	}
	}

	/*!
	* \internal
	* \brief Check whether a directory entry matches the upgrade XSLT pattern
	*
	* \param[in] entry Directory entry whose filename to check
	*
	* \return 1 if the entry's filename is of the form
	* <tt>upgrade-X.Y-ORDER.xsl</tt>, or 0 otherwise
	*/
	static int
	transform_filter(const struct dirent *entry)
	{
	return pcmk__str_eq(entry->d_name,
	"upgrade-[[:digit:]]+.[[:digit:]]+-[[:digit:]]+.xsl",
	pcmk__str_regex)? 1 : 0;
	}

	/*!
	* \internal
	* \brief Free a list of XSLT transform <tt>struct dirent</tt> objects
	*
	* \param[in,out] data List to free
	*/
	static void
	free_transform_list(void *data)
	{
	g_list_free_full((GList *) data, free);
	}

	/*!
	* \internal
	* \brief Load names of upgrade XSLT stylesheets from a directory into a table
	*
	* Stylesheets must have names of the form "upgrade-X.Y-order.xsl", where:
	* * X is the schema major version
	* * Y is the schema minor version
	* * ORDER is the order in which the stylesheet occurs in the transform pipeline
	*
	* \param[in] dir Directory containing XSLT stylesheets
	*
	* \return Table with schema version as key and \c GList of associated transform
	* files (as <tt>struct dirent</tt>) as value
	*/
	static GHashTable *
	load_transforms_from_dir(const char *dir)
	{
	struct dirent **namelist = NULL;
	int num_matches = scandir(dir, &namelist, transform_filter, versionsort);
	GHashTable *transforms = pcmk__strkey_table(free, free_transform_list);

	for (int i = 0; i < num_matches; i++) {
	pcmk__schema_version_t version = SCHEMA_ZERO;
	int order = 0; // Placeholder only

	if (sscanf(namelist[i]->d_name, "upgrade-%hhu.%hhu-%d.xsl",
	&(version.v[0]), &(version.v[1]), &order) == 3) {

	char *version_s = crm_strdup_printf("%hhu.%hhu",
	version.v[0], version.v[1]);
	GList *list = g_hash_table_lookup(transforms, version_s);

	if (list == NULL) {
	/* Prepend is more efficient. However, there won't be many of
	* these, and we want them to remain sorted by version. It's not
	* worth reversing all the lists at the end.
	*
	* Avoid calling g_hash_table_insert() if the list already
	* exists. Otherwise free_transform_list() gets called on it.
	*/
	list = g_list_append(list, namelist[i]);
	g_hash_table_insert(transforms, version_s, list);

	} else {
	list = g_list_append(list, namelist[i]);
	free(version_s);
	}

	} else {
	// Sanity only, should never happen thanks to transform_filter()
	free(namelist[i]);
	}
	}

	free(namelist);
	return transforms;
	}

	void
	pcmk__load_schemas_from_dir(const char *dir)
	{
	int lpc, max;
	struct dirent **namelist = NULL;
	GHashTable *transforms = NULL;

	max = scandir(dir, &namelist, schema_filter, schema_cmp_directory);
	if (max < 0) {
	crm_warn("Could not load schemas from %s: %s", dir, strerror(errno));
	return;
	}

	// Look for any upgrade transforms in the same directory
	transforms = load_transforms_from_dir(dir);

	for (lpc = 0; lpc < max; lpc++) {
	pcmk__schema_version_t version = SCHEMA_ZERO;

	if (version_from_filename(namelist[lpc]->d_name, &version)) {
	char *version_s = crm_strdup_printf("%hhu.%hhu",
	version.v[0], version.v[1]);
	char *orig_key = NULL;
	GList *transform_list = NULL;

	// The schema becomes the owner of transform_list
	g_hash_table_lookup_extended(transforms, version_s,
	(gpointer *) &orig_key,
	(gpointer *) &transform_list);
	g_hash_table_steal(transforms, version_s);

	add_schema(pcmk__schema_validator_rng, &version, NULL,
	transform_list);

	free(version_s);
	free(orig_key);

	} else {
	// Shouldn't be possible, but makes static analysis happy
	crm_warn("Skipping schema '%s': could not parse version",
	namelist[lpc]->d_name);
	}
	}

	for (lpc = 0; lpc < max; lpc++) {
	free(namelist[lpc]);
	}

	free(namelist);
	g_hash_table_destroy(transforms);
	}

	static gint
	schema_sort_GCompareFunc(gconstpointer a, gconstpointer b)
	{
	const pcmk__schema_t *schema_a = a;
	const pcmk__schema_t *schema_b = b;

	// @COMPAT pacemaker-next is deprecated since 2.1.5 and none since 2.1.8
	if (pcmk__str_eq(schema_a->name, "pacemaker-next", pcmk__str_none)) {
	if (pcmk__str_eq(schema_b->name, PCMK_VALUE_NONE, pcmk__str_none)) {
	return -1;
	} else {
	return 1;
	}
	} else if (pcmk__str_eq(schema_a->name, PCMK_VALUE_NONE, pcmk__str_none)) {
	return 1;
	} else if (pcmk__str_eq(schema_b->name, "pacemaker-next", pcmk__str_none)) {
	return -1;
	} else {
	return schema_cmp(schema_a->version, schema_b->version);
	}
	}

	/*!
	* \internal
	* \brief Sort the list of known schemas such that all pacemaker-X.Y are in
	* version order, then pacemaker-next, then none
	*
	* This function should be called whenever additional schemas are loaded using
	* \c pcmk__load_schemas_from_dir(), after the initial sets in
	* \c pcmk__schema_init().
	*/
	void
	pcmk__sort_schemas(void)
	{
	known_schemas = g_list_sort(known_schemas, schema_sort_GCompareFunc);
	}

	/*!
	* \internal
	* \brief Load pacemaker schemas into cache
	*
	* \note This currently also serves as an entry point for the
	* generic initialization of the libxslt library.
	*/
	void
	pcmk__schema_init(void)
	{
	if (!initialized) {
	const char *remote_schema_dir = pcmk__remote_schema_dir();
	char *base = pcmk__xml_artefact_root(pcmk__xml_artefact_ns_legacy_rng);
	const pcmk__schema_version_t zero = SCHEMA_ZERO;
	int schema_index = 0;

	initialized = true;

	wrap_libxslt(false);

	pcmk__load_schemas_from_dir(base);
	pcmk__load_schemas_from_dir(remote_schema_dir);
	free(base);

	// @COMPAT: Deprecated since 2.1.5
	add_schema(pcmk__schema_validator_rng, &zero, "pacemaker-next", NULL);

	// @COMPAT Deprecated since 2.1.8
	add_schema(pcmk__schema_validator_none, &zero, PCMK_VALUE_NONE, NULL);

	/* add_schema() prepends items to the list, so in the simple case, this
	* just reverses the list. However if there were any remote schemas,
	* sorting is necessary.
	*/
	pcmk__sort_schemas();

	// Now set the schema indexes and log the final result
	for (GList *iter = known_schemas; iter != NULL; iter = iter->next) {
	pcmk__schema_t *schema = iter->data;

	crm_debug("Loaded schema %d: %s", schema_index, schema->name);
	schema->schema_index = schema_index++;
	}
	}
	}

	static bool
	validate_with_relaxng(xmlDocPtr doc, xmlRelaxNGValidityErrorFunc error_handler,
	void error_handler_context, const char relaxng_file,
	relaxng_ctx_cache_t **cached_ctx)
	{
	int rc = 0;
	bool valid = true;
	relaxng_ctx_cache_t *ctx = NULL;

	CRM_CHECK(doc != NULL, return false);
	CRM_CHECK(relaxng_file != NULL, return false);

	if (cached_ctx && *cached_ctx) {
	ctx = *cached_ctx;

	} else {
	crm_debug("Creating RNG parser context");
	ctx = pcmk__assert_alloc(1, sizeof(relaxng_ctx_cache_t));

	ctx->parser = xmlRelaxNGNewParserCtxt(relaxng_file);
	CRM_CHECK(ctx->parser != NULL, goto cleanup);

	if (error_handler) {
	xmlRelaxNGSetParserErrors(ctx->parser,
	(xmlRelaxNGValidityErrorFunc) error_handler,
	(xmlRelaxNGValidityWarningFunc) error_handler,
	error_handler_context);
	} else {
	xmlRelaxNGSetParserErrors(ctx->parser,
	(xmlRelaxNGValidityErrorFunc) fprintf,
	(xmlRelaxNGValidityWarningFunc) fprintf,
	stderr);
	}

	ctx->rng = xmlRelaxNGParse(ctx->parser);
	CRM_CHECK(ctx->rng != NULL,
	crm_err("Could not find/parse %s", relaxng_file);
	goto cleanup);

	ctx->valid = xmlRelaxNGNewValidCtxt(ctx->rng);
	CRM_CHECK(ctx->valid != NULL, goto cleanup);

	if (error_handler) {
	xmlRelaxNGSetValidErrors(ctx->valid,
	(xmlRelaxNGValidityErrorFunc) error_handler,
	(xmlRelaxNGValidityWarningFunc) error_handler,
	error_handler_context);
	} else {
	xmlRelaxNGSetValidErrors(ctx->valid,
	(xmlRelaxNGValidityErrorFunc) fprintf,
	(xmlRelaxNGValidityWarningFunc) fprintf,
	stderr);
	}
	}

	rc = xmlRelaxNGValidateDoc(ctx->valid, doc);
	if (rc > 0) {
	valid = false;

	} else if (rc < 0) {
	crm_err("Internal libxml error during validation");
	}

	cleanup:

	if (cached_ctx) {
	*cached_ctx = ctx;

	} else {
	if (ctx->parser != NULL) {
	xmlRelaxNGFreeParserCtxt(ctx->parser);
	}
	if (ctx->valid != NULL) {
	xmlRelaxNGFreeValidCtxt(ctx->valid);
	}
	if (ctx->rng != NULL) {
	xmlRelaxNGFree(ctx->rng);
	}
	free(ctx);
	}

	return valid;
	}

	static void
	free_schema(gpointer data)
	{
	pcmk__schema_t *schema = data;
	relaxng_ctx_cache_t *ctx = NULL;

	switch (schema->validator) {
	case pcmk__schema_validator_none: // not cached
	break;

	case pcmk__schema_validator_rng: // cached
	ctx = (relaxng_ctx_cache_t *) schema->cache;
	if (ctx == NULL) {
	break;
	}

	if (ctx->parser != NULL) {
	xmlRelaxNGFreeParserCtxt(ctx->parser);
	}

	if (ctx->valid != NULL) {
	xmlRelaxNGFreeValidCtxt(ctx->valid);
	}

	if (ctx->rng != NULL) {
	xmlRelaxNGFree(ctx->rng);
	}

	free(ctx);
	schema->cache = NULL;
	break;
	}

	free(schema->name);
	g_list_free_full(schema->transforms, free);
	free(schema);
	}

	/*!
	* \internal
	* \brief Clean up global memory associated with XML schemas
	*/
	void
	pcmk__schema_cleanup(void)
	{
	if (known_schemas != NULL) {
	g_list_free_full(known_schemas, free_schema);
	known_schemas = NULL;
	}
	initialized = false;

	wrap_libxslt(true);
	}

	/*!
	* \internal
	* \brief Get schema list entry corresponding to a schema name
	*
	* \param[in] name Name of schema to get
	*
	* \return Schema list entry corresponding to \p name, or NULL if unknown
	*/
	GList *
	pcmk__get_schema(const char *name)
	{
	// @COMPAT Not specifying a schema name is deprecated since 2.1.8
	if (name == NULL) {
	name = PCMK_VALUE_NONE;
	}
	for (GList *iter = known_schemas; iter != NULL; iter = iter->next) {
	pcmk__schema_t *schema = iter->data;

	if (pcmk__str_eq(name, schema->name, pcmk__str_casei)) {
	return iter;
	}
	}
	return NULL;
	}

	/*!
	* \internal
	* \brief Compare two schema version numbers given the schema names
	*
	* \param[in] schema1 Name of first schema to compare
	* \param[in] schema2 Name of second schema to compare
	*
	* \return Standard comparison result (negative integer if \p schema1 has the
	* lower version number, positive integer if \p schema1 has the higher
	* version number, of 0 if the version numbers are equal)
	*/
	int
	pcmk__cmp_schemas_by_name(const char schema1_name, const char schema2_name)
	{
	GList *entry1 = pcmk__get_schema(schema1_name);
	GList *entry2 = pcmk__get_schema(schema2_name);

	if (entry1 == NULL) {
	return (entry2 == NULL)? 0 : -1;

	} else if (entry2 == NULL) {
	return 1;

	} else {
	pcmk__schema_t *schema1 = entry1->data;
	pcmk__schema_t *schema2 = entry2->data;

	return schema1->schema_index - schema2->schema_index;
	}
	}

	static bool
	validate_with(xmlNode xml, pcmk__schema_t schema,
	xmlRelaxNGValidityErrorFunc error_handler,
	void *error_handler_context)
	{
	bool valid = false;
	char *file = NULL;
	relaxng_ctx_cache_t **cache = NULL;

	if (schema == NULL) {
	return false;
	}

	if (schema->validator == pcmk__schema_validator_none) {
	return true;
	}

	file = pcmk__xml_artefact_path(pcmk__xml_artefact_ns_legacy_rng,
	schema->name);

	crm_trace("Validating with %s (type=%d)",
	pcmk__s(file, "missing schema"), schema->validator);
	switch (schema->validator) {
	case pcmk__schema_validator_rng:
	cache = (relaxng_ctx_cache_t **) &(schema->cache);
	valid = validate_with_relaxng(xml->doc, error_handler, error_handler_context, file, cache);
	break;
	default:
	crm_err("Unknown validator type: %d", schema->validator);
	break;
	}

	free(file);
	return valid;
	}

	static bool
	validate_with_silent(xmlNode xml, pcmk__schema_t schema)
	{
	bool rc, sl_backup = silent_logging;
	silent_logging = TRUE;
	rc = validate_with(xml, schema, (xmlRelaxNGValidityErrorFunc) xml_log, GUINT_TO_POINTER(LOG_ERR));
	silent_logging = sl_backup;
	return rc;
	}

	bool
	pcmk__validate_xml(xmlNode xml_blob, const char validation,
	xmlRelaxNGValidityErrorFunc error_handler,
	void *error_handler_context)
	{
	GList *entry = NULL;
	pcmk__schema_t *schema = NULL;

	CRM_CHECK((xml_blob != NULL) && (xml_blob->doc != NULL), return false);

	if (validation == NULL) {
	validation = crm_element_value(xml_blob, PCMK_XA_VALIDATE_WITH);
	}
	pcmk__warn_if_schema_deprecated(validation);

	// @COMPAT Not specifying a schema name is deprecated since 2.1.8
	if (validation == NULL) {
	bool valid = false;

	for (entry = known_schemas; entry != NULL; entry = entry->next) {
	schema = entry->data;
	if (validate_with(xml_blob, schema, NULL, NULL)) {
	valid = true;
	crm_xml_add(xml_blob, PCMK_XA_VALIDATE_WITH, schema->name);
	crm_info("XML validated against %s", schema->name);
	}
	}
	return valid;
	}

	entry = pcmk__get_schema(validation);
	if (entry == NULL) {
	pcmk__config_err("Cannot validate CIB with " PCMK_XA_VALIDATE_WITH
	" set to an unknown schema such as '%s' (manually"
	" edit to use a known schema)",
	validation);
	return false;
	}

	schema = entry->data;
	return validate_with(xml_blob, schema, error_handler,
	error_handler_context);
	}

	/*!
	* \internal
	* \brief Validate XML using its configured schema (and send errors to logs)
	*
	* \param[in] xml XML to validate
	*
	* \return true if XML validates, otherwise false
	*/
	bool
	pcmk__configured_schema_validates(xmlNode *xml)
	{
	return pcmk__validate_xml(xml, NULL,
	(xmlRelaxNGValidityErrorFunc) xml_log,
	GUINT_TO_POINTER(LOG_ERR));
	}

	/* With this arrangement, an attempt to identify the message severity
	as explicitly signalled directly from XSLT is performed in rather
	a smart way (no reliance on formatting string + arguments being
	always specified as ["%s", purposeful_string], as it can also be
	["%s: %s", some_prefix, purposeful_string] etc. so every argument
	pertaining %s specifier is investigated), and if such a mark found,
	the respective level is determined and, when the messages are to go
	to the native logs, the mark itself gets dropped
	(by the means of string shift).

	NOTE: whether the native logging is the right sink is decided per
	the ctx parameter -- NULL denotes this case, otherwise it
	carries a pointer to the numeric expression of the desired
	target logging level (messages with higher level will be
	suppressed)

	NOTE: on some architectures, this string shift may not have any
	effect, but that's an acceptable tradeoff

	The logging level for not explicitly designated messages
	(suspicious, likely internal errors or some runaways) is
	LOG_WARNING.
	*/
	static void G_GNUC_PRINTF(2, 3)
	cib_upgrade_err(void ctx, const char fmt, ...)
	{
	va_list ap, aq;
	char *arg_cur;

	bool found = FALSE;
	const char *fmt_iter = fmt;
	uint8_t msg_log_level = LOG_WARNING; /* default for runaway messages */
	const unsigned * log_level = (const unsigned *) ctx;
	enum {
	escan_seennothing,
	escan_seenpercent,
	} scan_state = escan_seennothing;

	va_start(ap, fmt);
	va_copy(aq, ap);

	while (!found && *fmt_iter != '\0') {
	/* while casing schema borrowed from libqb:qb_vsnprintf_serialize */
	switch (*fmt_iter++) {
	case '%':
	if (scan_state == escan_seennothing) {
	scan_state = escan_seenpercent;
	} else if (scan_state == escan_seenpercent) {
	scan_state = escan_seennothing;
	}
	break;
	case 's':
	if (scan_state == escan_seenpercent) {
	scan_state = escan_seennothing;
	arg_cur = va_arg(aq, char *);
	if (arg_cur != NULL) {
	switch (arg_cur[0]) {
	case 'W':
	if (!strncmp(arg_cur, "WARNING: ",
	sizeof("WARNING: ") - 1)) {
	msg_log_level = LOG_WARNING;
	}
	if (ctx == NULL) {
	memmove(arg_cur, arg_cur + sizeof("WARNING: ") - 1,
	strlen(arg_cur + sizeof("WARNING: ") - 1) + 1);
	}
	found = TRUE;
	break;
	case 'I':
	if (!strncmp(arg_cur, "INFO: ",
	sizeof("INFO: ") - 1)) {
	msg_log_level = LOG_INFO;
	}
	if (ctx == NULL) {
	memmove(arg_cur, arg_cur + sizeof("INFO: ") - 1,
	strlen(arg_cur + sizeof("INFO: ") - 1) + 1);
	}
	found = TRUE;
	break;
	case 'D':
	if (!strncmp(arg_cur, "DEBUG: ",
	sizeof("DEBUG: ") - 1)) {
	msg_log_level = LOG_DEBUG;
	}
	if (ctx == NULL) {
	memmove(arg_cur, arg_cur + sizeof("DEBUG: ") - 1,
	strlen(arg_cur + sizeof("DEBUG: ") - 1) + 1);
	}
	found = TRUE;
	break;
	}
	}
	}
	break;
	case '#': case '-': case ' ': case '+': case '\'': case 'I': case '.':
	case '0': case '1': case '2': case '3': case '4':
	case '5': case '6': case '7': case '8': case '9':
	case '*':
	break;
	case 'l':
	case 'z':
	case 't':
	case 'j':
	case 'd': case 'i':
	case 'o':
	case 'u':
	case 'x': case 'X':
	case 'e': case 'E':
	case 'f': case 'F':
	case 'g': case 'G':
	case 'a': case 'A':
	case 'c':
	case 'p':
	if (scan_state == escan_seenpercent) {
	(void) va_arg(aq, void ); / skip forward */
	scan_state = escan_seennothing;
	}
	break;
	default:
	scan_state = escan_seennothing;
	break;
	}
	}

	if (log_level != NULL) {
	/* intention of the following offset is:
	cibadmin -V -> start showing INFO labelled messages */
	if (*log_level + 4 >= msg_log_level) {
	vfprintf(stderr, fmt, ap);
	}
	} else {
	PCMK__XML_LOG_BASE(msg_log_level, TRUE, 0, "CIB upgrade: ", fmt, ap);
	}

	va_end(aq);
	va_end(ap);
	}

	/*!
	* \internal
	* \brief Apply a single XSL transformation to given XML
	*
	* \param[in] xml XML to transform
	* \param[in] transform XSL name
	* \param[in] to_logs If false, certain validation errors will be sent to
	* stderr rather than logged
	*
	* \return Transformed XML on success, otherwise NULL
	*/
	static xmlNode *
	apply_transformation(const xmlNode xml, const char transform,
	gboolean to_logs)
	{
	char *xform = NULL;
	xmlNode *out = NULL;
	xmlDocPtr res = NULL;
	xsltStylesheet *xslt = NULL;

	xform = pcmk__xml_artefact_path(pcmk__xml_artefact_ns_legacy_xslt,
	transform);

	/* for capturing, e.g., what's emitted via <xsl:message> */
	if (to_logs) {
	xsltSetGenericErrorFunc(NULL, cib_upgrade_err);
	} else {
	xsltSetGenericErrorFunc(&crm_log_level, cib_upgrade_err);
	}

	xslt = xsltParseStylesheetFile((pcmkXmlStr) xform);
	CRM_CHECK(xslt != NULL, goto cleanup);

	res = xsltApplyStylesheet(xslt, xml->doc, NULL);
	CRM_CHECK(res != NULL, goto cleanup);

	xsltSetGenericErrorFunc(NULL, NULL); /* restore default one */

	out = xmlDocGetRootElement(res);

	cleanup:
	if (xslt) {
	xsltFreeStylesheet(xslt);
	}

	free(xform);

	return out;
	}

	/*!
	* \internal
	* \brief Perform all transformations needed to upgrade XML to next schema
	*
	* \param[in] input_xml XML to transform
	* \param[in] schema_index Index of schema that successfully validates
	* \p original_xml
	* \param[in] to_logs If false, certain validation errors will be sent to
	* stderr rather than logged
	*
	* \return XML result of schema transforms if successful, otherwise NULL
	*/
	static xmlNode *
	apply_upgrade(const xmlNode *input_xml, int schema_index, gboolean to_logs)
	{
	pcmk__schema_t *schema = g_list_nth_data(known_schemas, schema_index);
	pcmk__schema_t *upgraded_schema = g_list_nth_data(known_schemas,
	schema_index + 1);

	xmlNode *old_xml = NULL;
	xmlNode *new_xml = NULL;
	xmlRelaxNGValidityErrorFunc error_handler = NULL;

	CRM_ASSERT((schema != NULL) && (upgraded_schema != NULL));

	if (to_logs) {
	error_handler = (xmlRelaxNGValidityErrorFunc) xml_log;
	}

	for (GList *iter = schema->transforms; iter != NULL; iter = iter->next) {
	const struct dirent *entry = iter->data;
	const char *transform = entry->d_name;

	crm_debug("Upgrading schema from %s to %s: applying XSL transform %s",
	schema->name, upgraded_schema->name, transform);

	new_xml = apply_transformation(input_xml, transform, to_logs);
	pcmk__xml_free(old_xml);

	if (new_xml == NULL) {
	crm_err("XSL transform %s failed, aborting upgrade", transform);
	return NULL;
	}
	input_xml = new_xml;
	old_xml = new_xml;
	}

	// Ensure result validates with its new schema
	if (!validate_with(new_xml, upgraded_schema, error_handler,
	GUINT_TO_POINTER(LOG_ERR))) {
	crm_err("Schema upgrade from %s to %s failed: "
	"XSL transform pipeline produced an invalid configuration",
	schema->name, upgraded_schema->name);
	crm_log_xml_debug(new_xml, "bad-transform-result");
	pcmk__xml_free(new_xml);
	return NULL;
	}

	crm_info("Schema upgrade from %s to %s succeeded",
	schema->name, upgraded_schema->name);
	return new_xml;
	}

	/*!
	* \internal
	* \brief Get the schema list entry corresponding to XML configuration
	*
	* \param[in] xml CIB XML to check
	*
	* \return List entry of schema configured in \p xml
	*/
	static GList *
	get_configured_schema(const xmlNode *xml)
	{
	const char *schema_name = crm_element_value(xml, PCMK_XA_VALIDATE_WITH);

	pcmk__warn_if_schema_deprecated(schema_name);
	if (schema_name == NULL) {
	return NULL;
	}
	return pcmk__get_schema(schema_name);
	}

	/*!
	* \brief Update CIB XML to latest schema that validates it
	*
	* \param[in,out] xml XML to update (may be freed and replaced
	* after being transformed)
	* \param[in] max_schema_name If not NULL, do not update \p xml to any
	* schema later than this one
	* \param[in] transform If false, do not update \p xml to any schema
	* that requires an XSL transform
	* \param[in] to_logs If false, certain validation errors will be
	* sent to stderr rather than logged
	*
	* \return Standard Pacemaker return code
	*/
	int
	pcmk__update_schema(xmlNode *xml, const char max_schema_name, bool transform,
	bool to_logs)
	{
	int max_stable_schemas = xml_latest_schema_index();
	int max_schema_index = 0;
	int rc = pcmk_rc_ok;
	GList *entry = NULL;
	pcmk__schema_t *best_schema = NULL;
	pcmk__schema_t *original_schema = NULL;
	xmlRelaxNGValidityErrorFunc error_handler =
	to_logs ? (xmlRelaxNGValidityErrorFunc) xml_log : NULL;

	CRM_CHECK((xml != NULL) && (xml != NULL) && ((xml)->doc != NULL),
	return EINVAL);

	if (max_schema_name != NULL) {
	GList *max_entry = pcmk__get_schema(max_schema_name);

	if (max_entry != NULL) {
	pcmk__schema_t *max_schema = max_entry->data;

	max_schema_index = max_schema->schema_index;
	}
	}
	if ((max_schema_index < 1) \|\| (max_schema_index > max_stable_schemas)) {
	max_schema_index = max_stable_schemas;
	}

	entry = get_configured_schema(*xml);
	if (entry == NULL) {
	// @COMPAT Not specifying a schema name is deprecated since 2.1.8
	entry = known_schemas;
	} else {
	original_schema = entry->data;
	if (original_schema->schema_index >= max_schema_index) {
	return pcmk_rc_ok;
	}
	}

	for (; entry != NULL; entry = entry->next) {
	pcmk__schema_t *current_schema = entry->data;
	xmlNode *upgrade = NULL;

	if (current_schema->schema_index > max_schema_index) {
	break;
	}

	if (!validate_with(*xml, current_schema, error_handler,
	GUINT_TO_POINTER(LOG_ERR))) {
	crm_debug("Schema %s does not validate", current_schema->name);
	if (best_schema != NULL) {
	/* we've satisfied the validation, no need to check further */
	break;
	}
	rc = pcmk_rc_schema_validation;
	continue; // Try again with the next higher schema
	}

	crm_debug("Schema %s validates", current_schema->name);
	rc = pcmk_rc_ok;
	best_schema = current_schema;
	if (current_schema->schema_index == max_schema_index) {
	break; // No further transformations possible
	}

	if (!transform \|\| (current_schema->transforms == NULL)
	\|\| validate_with_silent(*xml, entry->next->data)) {
	/* The next schema either doesn't require a transform or validates
	* successfully even without the transform. Skip the transform and
	* try the next schema with the same XML.
	*/
	continue;
	}

	upgrade = apply_upgrade(*xml, current_schema->schema_index, to_logs);
	if (upgrade == NULL) {
	/* The transform failed, so this schema can't be used. Later
	* schemas are unlikely to validate, but try anyway until we
	* run out of options.
	*/
	rc = pcmk_rc_transform_failed;
	} else {
	best_schema = current_schema;
	pcmk__xml_free(*xml);
	*xml = upgrade;
	}
	}

	if (best_schema != NULL) {
	if ((original_schema == NULL)
	\|\| (best_schema->schema_index > original_schema->schema_index)) {
	crm_info("%s the configuration schema to %s",
	(transform? "Transformed" : "Upgraded"),
	best_schema->name);
	crm_xml_add(*xml, PCMK_XA_VALIDATE_WITH, best_schema->name);
	}
	}
	return rc;
	}

	+int
	+pcmk_update_configured_schema(xmlNode **xml)
	+{
	+ return pcmk__update_configured_schema(xml, true);
	+}
	+
	/*!
	* \brief Update XML from its configured schema to the latest major series
	*
	* \param[in,out] xml XML to update
	* \param[in] to_logs If false, certain validation errors will be
	* sent to stderr rather than logged
	*
	* \return Standard Pacemaker return code
	*/
	int
	-pcmk_update_configured_schema(xmlNode **xml, bool to_logs)
	+pcmk__update_configured_schema(xmlNode **xml, bool to_logs)
	{
	int rc = pcmk_rc_ok;
	char *original_schema_name = NULL;

	// @COMPAT Not specifying a schema name is deprecated since 2.1.8
	const char *effective_original_name = "the first";

	int orig_version = -1;
	pcmk__schema_t *x_0_schema = pcmk__find_x_0_schema()->data;
	GList *entry = NULL;

	CRM_CHECK(xml != NULL, return EINVAL);

	original_schema_name = crm_element_value_copy(*xml, PCMK_XA_VALIDATE_WITH);
	pcmk__warn_if_schema_deprecated(original_schema_name);
	entry = pcmk__get_schema(original_schema_name);
	if (entry != NULL) {
	pcmk__schema_t *original_schema = entry->data;

	effective_original_name = original_schema->name;
	orig_version = original_schema->schema_index;
	}

	if (orig_version < x_0_schema->schema_index) {
	// Current configuration schema is not acceptable, try to update
	xmlNode *converted = NULL;
	const char *new_schema_name = NULL;
	pcmk__schema_t *schema = NULL;

	entry = NULL;
	converted = pcmk__xml_copy(NULL, *xml);
	if (pcmk__update_schema(&converted, NULL, true, to_logs) == pcmk_rc_ok) {
	new_schema_name = crm_element_value(converted,
	PCMK_XA_VALIDATE_WITH);
	entry = pcmk__get_schema(new_schema_name);
	}
	schema = (entry == NULL)? NULL : entry->data;

	if ((schema == NULL)
	\|\| (schema->schema_index < x_0_schema->schema_index)) {
	// Updated configuration schema is still not acceptable

	if ((orig_version == -1) \|\| (schema == NULL)
	\|\| (schema->schema_index < orig_version)) {
	// We couldn't validate any schema at all
	if (to_logs) {
	pcmk__config_err("Cannot upgrade configuration (claiming "
	"%s schema) to at least %s because it "
	"does not validate with any schema from "
	"%s to the latest",
	pcmk__s(original_schema_name, "no"),
	x_0_schema->name, effective_original_name);
	} else {
	fprintf(stderr, "Cannot upgrade configuration (claiming "
	"%s schema) to at least %s because it "
	"does not validate with any schema from "
	"%s to the latest\n",
	pcmk__s(original_schema_name, "no"),
	x_0_schema->name, effective_original_name);
	}
	} else {
	// We updated configuration successfully, but still too low
	if (to_logs) {
	pcmk__config_err("Cannot upgrade configuration (claiming "
	"%s schema) to at least %s because it "
	"would not upgrade past %s",
	pcmk__s(original_schema_name, "no"),
	x_0_schema->name,
	pcmk__s(new_schema_name, "unspecified version"));
	} else {
	fprintf(stderr, "Cannot upgrade configuration (claiming "
	"%s schema) to at least %s because it "
	"would not upgrade past %s\n",
	pcmk__s(original_schema_name, "no"),
	x_0_schema->name,
	pcmk__s(new_schema_name, "unspecified version"));
	}
	}

	pcmk__xml_free(converted);
	converted = NULL;
	rc = pcmk_rc_transform_failed;

	} else {
	// Updated configuration schema is acceptable
	pcmk__xml_free(*xml);
	*xml = converted;

	if (schema->schema_index < xml_latest_schema_index()) {
	if (to_logs) {
	pcmk__config_warn("Configuration with %s schema was "
	"internally upgraded to acceptable (but "
	"not most recent) %s",
	pcmk__s(original_schema_name, "no"),
	schema->name);
	}
	} else if (to_logs) {
	crm_info("Configuration with %s schema was internally "
	"upgraded to latest version %s",
	pcmk__s(original_schema_name, "no"),
	schema->name);
	}
	}

	} else {
	// @COMPAT the none schema is deprecated since 2.1.8
	pcmk__schema_t *none_schema = NULL;

	entry = pcmk__get_schema(PCMK_VALUE_NONE);
	CRM_ASSERT((entry != NULL) && (entry->data != NULL));

	none_schema = entry->data;
	if (!to_logs && (orig_version >= none_schema->schema_index)) {
	fprintf(stderr, "Schema validation of configuration is "
	"disabled (support for " PCMK_XA_VALIDATE_WITH
	" set to \"" PCMK_VALUE_NONE "\" is deprecated"
	" and will be removed in a future release)\n");
	}
	}

	free(original_schema_name);
	return rc;
	}

	/*!
	* \internal
	* \brief Return a list of all schema files and any associated XSLT files
	* later than the given one
	* \brief Return a list of all schema versions later than the given one
	*
	* \param[in] schema The schema to compare against (for example,
	* "pacemaker-3.1.rng" or "pacemaker-3.1")
	*
	* \note The caller is responsible for freeing both the returned list and
	* the elements of the list
	*/
	GList *
	pcmk__schema_files_later_than(const char *name)
	{
	GList *lst = NULL;
	pcmk__schema_version_t ver;

	if (!version_from_filename(name, &ver)) {
	return lst;
	}

	for (GList *iter = g_list_nth(known_schemas, xml_latest_schema_index());
	iter != NULL; iter = iter->prev) {
	pcmk__schema_t *schema = iter->data;

	if (schema_cmp(ver, schema->version) != -1) {
	continue;
	}

	for (GList *iter2 = g_list_last(schema->transforms); iter2 != NULL;
	iter2 = iter2->prev) {

	const struct dirent *entry = iter2->data;

	lst = g_list_prepend(lst, pcmk__str_copy(entry->d_name));
	}

	lst = g_list_prepend(lst, crm_strdup_printf("%s.rng", schema->name));
	}

	return lst;
	}

	static void
	append_href(xmlNode xml, void user_data)
	{
	GList **list = user_data;
	char *href = crm_element_value_copy(xml, "href");

	if (href == NULL) {
	return;
	}
	list = g_list_prepend(list, href);
	}

	static void
	external_refs_in_schema(GList *list, const char contents)
	{
	/* local-name()= is needed to ignore the xmlns= setting at the top of
	* the XML file. Otherwise, the xpath query will always return nothing.
	*/
	const char search = "//[local-name()='externalRef'] \| //*[local-name()='include']";
	xmlNode *xml = pcmk__xml_parse(contents);

	crm_foreach_xpath_result(xml, search, append_href, list);
	pcmk__xml_free(xml);
	}

	static int
	read_file_contents(const char file, char *contents)
	{
	int rc = pcmk_rc_ok;
	char *path = NULL;

	if (pcmk__ends_with(file, ".rng")) {
	path = pcmk__xml_artefact_path(pcmk__xml_artefact_ns_legacy_rng, file);
	} else {
	path = pcmk__xml_artefact_path(pcmk__xml_artefact_ns_legacy_xslt, file);
	}

	rc = pcmk__file_contents(path, contents);

	free(path);
	return rc;
	}

	static void
	add_schema_file_to_xml(xmlNode parent, const char file, GList **already_included)
	{
	char *contents = NULL;
	char *path = NULL;
	xmlNode *file_node = NULL;
	GList *includes = NULL;
	int rc = pcmk_rc_ok;

	/* If we already included this file, don't do so again. */
	if (g_list_find_custom(*already_included, file, (GCompareFunc) strcmp) != NULL) {
	return;
	}

	/* Ensure whatever file we were given has a suffix we know about. If not,
	* just assume it's an RNG file.
	*/
	if (!pcmk__ends_with(file, ".rng") && !pcmk__ends_with(file, ".xsl")) {
	path = crm_strdup_printf("%s.rng", file);
	} else {
	path = pcmk__str_copy(file);
	}

	rc = read_file_contents(path, &contents);
	if (rc != pcmk_rc_ok \|\| contents == NULL) {
	crm_warn("Could not read schema file %s: %s", file, pcmk_rc_str(rc));
	free(path);
	return;
	}

	/* Create a new <file path="..."> node with the contents of the file
	* as a CDATA block underneath it.
	*/
	file_node = pcmk__xe_create(parent, PCMK_XA_FILE);
	crm_xml_add(file_node, PCMK_XA_PATH, path);
	already_included = g_list_prepend(already_included, path);

	xmlAddChild(file_node, xmlNewCDataBlock(parent->doc, (pcmkXmlStr) contents,
	strlen(contents)));

	/* Scan the file for any <externalRef> or <include> nodes and build up
	* a list of the files they reference.
	*/
	external_refs_in_schema(&includes, contents);

	/* For each referenced file, recurse to add it (and potentially anything it
	* references, ...) to the XML.
	*/
	for (GList *iter = includes; iter != NULL; iter = iter->next) {
	add_schema_file_to_xml(parent, iter->data, already_included);
	}

	free(contents);
	g_list_free_full(includes, free);
	}

	/*!
	* \internal
	* \brief Add an XML schema file and all the files it references as children
	* of a given XML node
	*
	* \param[in,out] parent The parent XML node
	* \param[in] name The schema version to compare against
	* (for example, "pacemaker-3.1" or "pacemaker-3.1.rng")
	* \param[in,out] already_included A list of names that have already been added
	* to the parent node.
	*
	* \note The caller is responsible for freeing both the returned list and
	* the elements of the list
	*/
	void
	pcmk__build_schema_xml_node(xmlNode parent, const char name, GList **already_included)
	{
	xmlNode *schema_node = pcmk__xe_create(parent, PCMK__XA_SCHEMA);

	crm_xml_add(schema_node, PCMK_XA_VERSION, name);
	add_schema_file_to_xml(schema_node, name, already_included);

	if (schema_node->children == NULL) {
	// Not needed if empty. May happen if name was invalid, for example.
	pcmk__xml_free(schema_node);
	}
	}

	/*!
	* \internal
	* \brief Return the directory containing any extra schema files that a
	* Pacemaker Remote node fetched from the cluster
	*/
	const char *
	pcmk__remote_schema_dir(void)
	{
	const char *dir = pcmk__env_option(PCMK__ENV_REMOTE_SCHEMA_DIRECTORY);

	if (pcmk__str_empty(dir)) {
	return PCMK__REMOTE_SCHEMA_DIR;
	}

	return dir;
	}

	/*!
	* \internal
	* \brief Warn if a given validation schema is deprecated
	*
	* \param[in] Schema name to check
	*/
	void
	pcmk__warn_if_schema_deprecated(const char *schema)
	{
	if ((schema == NULL) \|\|
	pcmk__strcase_any_of(schema, "pacemaker-next", PCMK_VALUE_NONE, NULL)) {
	pcmk__config_warn("Support for " PCMK_XA_VALIDATE_WITH "='%s' is "
	"deprecated and will be removed in a future release "
	"without the possibility of upgrades (manually edit "
	"to use a supported schema)", pcmk__s(schema, ""));
	}
	}

	// Deprecated functions kept only for backward API compatibility
	// LCOV_EXCL_START

	#include <crm/common/xml_compat.h>

	gboolean
	cli_config_update(xmlNode *xml, int best_version, gboolean to_logs)
	{
	- int rc = pcmk_update_configured_schema(xml, to_logs);
	+ int rc = pcmk__update_configured_schema(xml, to_logs);

	if (best_version != NULL) {
	const char name = crm_element_value(xml, PCMK_XA_VALIDATE_WITH);

	if (name == NULL) {
	*best_version = -1;
	} else {
	GList *entry = pcmk__get_schema(name);
	pcmk__schema_t *schema = (entry == NULL)? NULL : entry->data;

	*best_version = (schema == NULL)? -1 : schema->schema_index;
	}
	}
	return (rc == pcmk_rc_ok)? TRUE: FALSE;
	}

	// LCOV_EXCL_STOP
	// End deprecated API
	diff --git a/lib/pacemaker/pcmk_simulate.c b/lib/pacemaker/pcmk_simulate.c
	index a74e4d2166..bc84bdb987 100644
	--- a/lib/pacemaker/pcmk_simulate.c
	+++ b/lib/pacemaker/pcmk_simulate.c
	@@ -1,1007 +1,1007 @@
	/*
	* Copyright 2021-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 <crm/cib/internal.h>
	#include <crm/common/output.h>
	#include <crm/common/results.h>
	#include <crm/common/scheduler.h>
	#include <pacemaker-internal.h>
	#include <pacemaker.h>

	#include <stdint.h>
	#include <sys/types.h>
	#include <sys/stat.h>
	#include <unistd.h>

	#include "libpacemaker_private.h"

	static pcmk__output_t *out = NULL;
	static cib_t *fake_cib = NULL;
	static GList *fake_resource_list = NULL;
	static const GList *fake_op_fail_list = NULL;

	static void set_effective_date(pcmk_scheduler_t *scheduler, bool print_original,
	const char *use_date);

	/*!
	* \internal
	* \brief Create an action name for use in a dot graph
	*
	* \param[in] action Action to create name for
	* \param[in] verbose If true, add action ID to name
	*
	* \return Newly allocated string with action name
	* \note It is the caller's responsibility to free the result.
	*/
	static char *
	create_action_name(const pcmk_action_t *action, bool verbose)
	{
	char *action_name = NULL;
	const char *prefix = "";
	const char *action_host = NULL;
	const char *history_id = NULL;
	const char *task = action->task;

	if (action->node != NULL) {
	action_host = action->node->priv->name;
	} else if (!pcmk_is_set(action->flags, pcmk__action_pseudo)) {
	action_host = "<none>";
	}

	if (pcmk__str_eq(action->task, PCMK_ACTION_CANCEL, pcmk__str_none)) {
	prefix = "Cancel ";
	task = action->cancel_task;
	}

	if (action->rsc != NULL) {
	history_id = action->rsc->priv->history_id;
	}

	if (history_id != NULL) {
	char *key = NULL;
	guint interval_ms = 0;

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

	if (pcmk__strcase_any_of(action->task, PCMK_ACTION_NOTIFY,
	PCMK_ACTION_NOTIFIED, NULL)) {
	const char *n_type = g_hash_table_lookup(action->meta,
	"notify_key_type");
	const char *n_task = g_hash_table_lookup(action->meta,
	"notify_key_operation");

	CRM_ASSERT(n_type != NULL);
	CRM_ASSERT(n_task != NULL);
	key = pcmk__notify_key(history_id, n_type, n_task);
	} else {
	key = pcmk__op_key(history_id, task, interval_ms);
	}

	if (action_host != NULL) {
	action_name = crm_strdup_printf("%s%s %s",
	prefix, key, action_host);
	} else {
	action_name = crm_strdup_printf("%s%s", prefix, key);
	}
	free(key);

	} else if (pcmk__str_eq(action->task, PCMK_ACTION_STONITH,
	pcmk__str_none)) {
	const char *op = g_hash_table_lookup(action->meta,
	PCMK__META_STONITH_ACTION);

	action_name = crm_strdup_printf("%s%s '%s' %s",
	prefix, action->task, op, action_host);

	} else if (action->rsc && action_host) {
	action_name = crm_strdup_printf("%s%s %s",
	prefix, action->uuid, action_host);

	} else if (action_host) {
	action_name = crm_strdup_printf("%s%s %s",
	prefix, action->task, action_host);

	} else {
	action_name = crm_strdup_printf("%s", action->uuid);
	}

	if (verbose) {
	char *with_id = crm_strdup_printf("%s (%d)", action_name, action->id);

	free(action_name);
	action_name = with_id;
	}
	return action_name;
	}

	/*!
	* \internal
	* \brief Display the status of a cluster
	*
	* \param[in,out] scheduler Scheduler data
	* \param[in] show_opts How to modify display (as pcmk_show_opt_e flags)
	* \param[in] section_opts Sections to display (as pcmk_section_e flags)
	* \param[in] title What to use as list title
	* \param[in] print_spacer Whether to display a spacer first
	*/
	static void
	print_cluster_status(pcmk_scheduler_t *scheduler, uint32_t show_opts,
	uint32_t section_opts, const char *title,
	bool print_spacer)
	{
	pcmk__output_t *out = scheduler->priv->out;
	GList *all = NULL;
	crm_exit_t stonith_rc = 0;
	enum pcmk_pacemakerd_state state = pcmk_pacemakerd_state_invalid;

	section_opts \|= pcmk_section_nodes \| pcmk_section_resources;
	show_opts \|= pcmk_show_inactive_rscs \| pcmk_show_failed_detail;

	all = g_list_prepend(all, (gpointer) "*");

	PCMK__OUTPUT_SPACER_IF(out, print_spacer);
	out->begin_list(out, NULL, NULL, "%s", title);
	out->message(out, "cluster-status",
	scheduler, state, stonith_rc, NULL,
	pcmk__fence_history_none, section_opts, show_opts, NULL,
	all, all);
	out->end_list(out);

	g_list_free(all);
	}

	/*!
	* \internal
	* \brief Display a summary of all actions scheduled in a transition
	*
	* \param[in,out] scheduler Scheduler data (fully scheduled)
	* \param[in] print_spacer Whether to display a spacer first
	*/
	static void
	print_transition_summary(pcmk_scheduler_t *scheduler, bool print_spacer)
	{
	pcmk__output_t *out = scheduler->priv->out;

	PCMK__OUTPUT_SPACER_IF(out, print_spacer);
	out->begin_list(out, NULL, NULL, "Transition Summary");
	pcmk__output_actions(scheduler);
	out->end_list(out);
	}

	/*!
	* \internal
	* \brief Reset scheduler input, output, date, and flags
	*
	* \param[in,out] scheduler Scheduler data
	* \param[in] input What to set as cluster input
	* \param[in] out What to set as cluster output object
	* \param[in] use_date What to set as cluster's current timestamp
	* \param[in] flags Group of enum pcmk__scheduler_flags to set
	*/
	static void
	reset(pcmk_scheduler_t scheduler, xmlNodePtr input, pcmk__output_t out,
	const char *use_date, unsigned int flags)
	{
	scheduler->input = input;
	scheduler->priv->out = out;
	set_effective_date(scheduler, true, use_date);
	if (pcmk_is_set(flags, pcmk_sim_sanitized)) {
	pcmk__set_scheduler_flags(scheduler, pcmk__sched_sanitized);
	}
	if (pcmk_is_set(flags, pcmk_sim_show_scores)) {
	pcmk__set_scheduler_flags(scheduler, pcmk__sched_output_scores);
	}
	if (pcmk_is_set(flags, pcmk_sim_show_utilization)) {
	pcmk__set_scheduler_flags(scheduler, pcmk__sched_show_utilization);
	}
	}

	/*!
	* \brief Write out a file in dot(1) format describing the actions that will
	* be taken by the scheduler in response to an input CIB file.
	*
	* \param[in,out] scheduler Scheduler data
	* \param[in] dot_file The filename to write
	* \param[in] all_actions Write all actions, even those that are optional
	* or are on unmanaged resources
	* \param[in] verbose Add extra information, such as action IDs, to the
	* output
	*
	* \return Standard Pacemaker return code
	*/
	static int
	write_sim_dotfile(pcmk_scheduler_t scheduler, const char dot_file,
	bool all_actions, bool verbose)
	{
	GList *iter = NULL;
	FILE *dot_strm = fopen(dot_file, "w");

	if (dot_strm == NULL) {
	return errno;
	}

	fprintf(dot_strm, " digraph \"g\" {\n");
	for (iter = scheduler->priv->actions; iter != NULL; iter = iter->next) {
	pcmk_action_t action = (pcmk_action_t ) iter->data;
	const char *style = "dashed";
	const char *font = "black";
	const char *color = "black";
	char *action_name = create_action_name(action, verbose);

	if (pcmk_is_set(action->flags, pcmk__action_pseudo)) {
	font = "orange";
	}

	if (pcmk_is_set(action->flags, pcmk__action_added_to_graph)) {
	style = PCMK__VALUE_BOLD;
	color = "green";

	} else if ((action->rsc != NULL)
	&& !pcmk_is_set(action->rsc->flags, pcmk__rsc_managed)) {
	color = "red";
	font = "purple";
	if (!all_actions) {
	goto do_not_write;
	}

	} else if (pcmk_is_set(action->flags, pcmk__action_optional)) {
	color = "blue";
	if (!all_actions) {
	goto do_not_write;
	}

	} else {
	color = "red";
	CRM_LOG_ASSERT(!pcmk_is_set(action->flags, pcmk__action_runnable));
	}

	pcmk__set_action_flags(action, pcmk__action_added_to_graph);
	fprintf(dot_strm, "\"%s\" [ style=%s color=\"%s\" fontcolor=\"%s\"]\n",
	action_name, style, color, font);
	do_not_write:
	free(action_name);
	}

	for (iter = scheduler->priv->actions; iter != NULL; iter = iter->next) {
	pcmk_action_t action = (pcmk_action_t ) iter->data;

	for (GList *before_iter = action->actions_before;
	before_iter != NULL; before_iter = before_iter->next) {

	pcmk__related_action_t *before = before_iter->data;

	char *before_name = NULL;
	char *after_name = NULL;
	const char *style = "dashed";
	bool optional = true;

	if (before->graphed) {
	optional = false;
	style = PCMK__VALUE_BOLD;
	} else if (before->flags == pcmk__ar_none) {
	continue;
	} else if (pcmk_is_set(before->action->flags,
	pcmk__action_added_to_graph)
	&& pcmk_is_set(action->flags, pcmk__action_added_to_graph)
	&& before->flags != pcmk__ar_if_on_same_node_or_target) {
	optional = false;
	}

	if (all_actions \|\| !optional) {
	before_name = create_action_name(before->action, verbose);
	after_name = create_action_name(action, verbose);
	fprintf(dot_strm, "\"%s\" -> \"%s\" [ style = %s]\n",
	before_name, after_name, style);
	free(before_name);
	free(after_name);
	}
	}
	}

	fprintf(dot_strm, "}\n");
	fflush(dot_strm);
	fclose(dot_strm);
	return pcmk_rc_ok;
	}

	/*!
	* \brief Profile the configuration updates and scheduler actions in a single
	* CIB file, printing the profiling timings.
	*
	* \note \p scheduler->priv->out must have been set to a valid \p pcmk__output_t
	* object before this function is called.
	*
	* \param[in] xml_file The CIB file to profile
	* \param[in] repeat Number of times to run
	* \param[in,out] scheduler Scheduler data
	* \param[in] use_date The date to set the cluster's time to (may be NULL)
	*/
	static void
	profile_file(const char *xml_file, long long repeat,
	pcmk_scheduler_t scheduler, const char use_date)
	{
	pcmk__output_t *out = scheduler->priv->out;
	xmlNode *cib_object = NULL;
	clock_t start = 0;
	clock_t end;
	unsigned long long scheduler_flags = pcmk__sched_none;

	CRM_ASSERT(out != NULL);

	cib_object = pcmk__xml_read(xml_file);
	start = clock();

	if (pcmk_find_cib_element(cib_object, PCMK_XE_STATUS) == NULL) {
	pcmk__xe_create(cib_object, PCMK_XE_STATUS);
	}

	- if (pcmk_update_configured_schema(&cib_object, false) != pcmk_rc_ok) {
	+ if (pcmk__update_configured_schema(&cib_object, false) != pcmk_rc_ok) {
	pcmk__xml_free(cib_object);
	return;
	}

	if (!pcmk__validate_xml(cib_object, NULL, NULL, NULL)) {
	pcmk__xml_free(cib_object);
	return;
	}

	if (pcmk_is_set(scheduler->flags, pcmk__sched_output_scores)) {
	scheduler_flags \|= pcmk__sched_output_scores;
	}
	if (pcmk_is_set(scheduler->flags, pcmk__sched_show_utilization)) {
	scheduler_flags \|= pcmk__sched_show_utilization;
	}

	for (int i = 0; i < repeat; ++i) {
	xmlNode *input = cib_object;

	if (repeat > 1) {
	input = pcmk__xml_copy(NULL, cib_object);
	}
	scheduler->input = input;
	set_effective_date(scheduler, false, use_date);
	pcmk__schedule_actions(input, scheduler_flags, scheduler);
	pe_reset_working_set(scheduler);
	}

	end = clock();
	out->message(out, "profile", xml_file, start, end);
	}

	void
	pcmk__profile_dir(const char *dir, long long repeat,
	pcmk_scheduler_t scheduler, const char use_date)
	{
	pcmk__output_t *out = scheduler->priv->out;
	struct dirent **namelist;

	int file_num = scandir(dir, &namelist, 0, alphasort);

	CRM_ASSERT(out != NULL);

	if (file_num > 0) {
	struct stat prop;
	char buffer[FILENAME_MAX];

	out->begin_list(out, NULL, NULL, "Timings");

	while (file_num--) {
	if ('.' == namelist[file_num]->d_name[0]) {
	free(namelist[file_num]);
	continue;

	} else if (!pcmk__ends_with_ext(namelist[file_num]->d_name,
	".xml")) {
	free(namelist[file_num]);
	continue;
	}
	snprintf(buffer, sizeof(buffer), "%s/%s",
	dir, namelist[file_num]->d_name);
	if (stat(buffer, &prop) == 0 && S_ISREG(prop.st_mode)) {
	profile_file(buffer, repeat, scheduler, use_date);
	}
	free(namelist[file_num]);
	}
	free(namelist);

	out->end_list(out);
	}
	}

	/*!
	* \brief Set the date of the cluster, either to the value given by
	* \p use_date, or to the \c PCMK_XA_EXECUTION_DATE value in the CIB.
	*
	* \note \p scheduler->priv->out must have been set to a valid \p pcmk__output_t
	* object before this function is called.
	*
	* \param[in,out] scheduler Scheduler data
	* \param[in] print_original If \p true, the \c PCMK_XA_EXECUTION_DATE
	* should also be printed
	* \param[in] use_date The date to set the cluster's time to
	* (may be NULL)
	*/
	static void
	set_effective_date(pcmk_scheduler_t *scheduler, bool print_original,
	const char *use_date)
	{
	pcmk__output_t *out = scheduler->priv->out;
	time_t original_date = 0;

	CRM_ASSERT(out != NULL);

	crm_element_value_epoch(scheduler->input, PCMK_XA_EXECUTION_DATE,
	&original_date);

	if (use_date) {
	scheduler->priv->now = crm_time_new(use_date);
	out->info(out, "Setting effective cluster time: %s", use_date);
	crm_time_log(LOG_NOTICE, "Pretending 'now' is", scheduler->priv->now,
	crm_time_log_date \| crm_time_log_timeofday);

	} else if (original_date != 0) {
	scheduler->priv->now = pcmk__copy_timet(original_date);

	if (print_original) {
	char *when = crm_time_as_string(scheduler->priv->now,
	crm_time_log_date
	\|crm_time_log_timeofday);

	out->info(out, "Using the original execution date of: %s", when);
	free(when);
	}
	}
	}

	/*!
	* \internal
	* \brief Simulate successfully executing a pseudo-action in a graph
	*
	* \param[in,out] graph Graph to update with pseudo-action result
	* \param[in,out] action Pseudo-action to simulate executing
	*
	* \return Standard Pacemaker return code
	*/
	static int
	simulate_pseudo_action(pcmk__graph_t graph, pcmk__graph_action_t action)
	{
	const char *node = crm_element_value(action->xml, PCMK__META_ON_NODE);
	const char *task = crm_element_value(action->xml, PCMK__XA_OPERATION_KEY);

	pcmk__set_graph_action_flags(action, pcmk__graph_action_confirmed);
	out->message(out, "inject-pseudo-action", node, task);

	pcmk__update_graph(graph, action);
	return pcmk_rc_ok;
	}

	/*!
	* \internal
	* \brief Simulate executing a resource action in a graph
	*
	* \param[in,out] graph Graph to update with resource action result
	* \param[in,out] action Resource action to simulate executing
	*
	* \return Standard Pacemaker return code
	*/
	static int
	simulate_resource_action(pcmk__graph_t graph, pcmk__graph_action_t action)
	{
	int rc;
	lrmd_event_data_t *op = NULL;
	int target_outcome = PCMK_OCF_OK;

	const char *rtype = NULL;
	const char *rclass = NULL;
	const char *resource = NULL;
	const char *rprovider = NULL;
	const char *resource_config_name = NULL;
	const char *operation = crm_element_value(action->xml, PCMK_XA_OPERATION);
	const char *target_rc_s = crm_meta_value(action->params,
	PCMK__META_OP_TARGET_RC);

	xmlNode *cib_node = NULL;
	xmlNode *cib_resource = NULL;
	xmlNode *action_rsc = pcmk__xe_first_child(action->xml, PCMK_XE_PRIMITIVE,
	NULL, NULL);

	char *node = crm_element_value_copy(action->xml, PCMK__META_ON_NODE);
	char *uuid = NULL;
	const char *router_node = crm_element_value(action->xml,
	PCMK__XA_ROUTER_NODE);

	// Certain actions don't need to be displayed or history entries
	if (pcmk__str_eq(operation, CRM_OP_REPROBE, pcmk__str_none)) {
	crm_debug("No history injection for %s op on %s", operation, node);
	goto done; // Confirm action and update graph
	}

	if (action_rsc == NULL) { // Shouldn't be possible
	crm_log_xml_err(action->xml, "Bad");
	free(node);
	return EPROTO;
	}

	/* A resource might be known by different names in the configuration and in
	* the action (for example, a clone instance). Grab the configuration name
	* (which is preferred when writing history), and if necessary, the instance
	* name.
	*/
	resource_config_name = crm_element_value(action_rsc, PCMK_XA_ID);
	if (resource_config_name == NULL) { // Shouldn't be possible
	crm_log_xml_err(action->xml, "No ID");
	free(node);
	return EPROTO;
	}
	resource = resource_config_name;
	if (pe_find_resource(fake_resource_list, resource) == NULL) {
	const char *longname = crm_element_value(action_rsc, PCMK__XA_LONG_ID);

	if ((longname != NULL)
	&& (pe_find_resource(fake_resource_list, longname) != NULL)) {
	resource = longname;
	}
	}

	// Certain actions need to be displayed but don't need history entries
	if (pcmk__strcase_any_of(operation, PCMK_ACTION_DELETE,
	PCMK_ACTION_META_DATA, NULL)) {
	out->message(out, "inject-rsc-action", resource, operation, node,
	(guint) 0);
	goto done; // Confirm action and update graph
	}

	rclass = crm_element_value(action_rsc, PCMK_XA_CLASS);
	rtype = crm_element_value(action_rsc, PCMK_XA_TYPE);
	rprovider = crm_element_value(action_rsc, PCMK_XA_PROVIDER);

	pcmk__scan_min_int(target_rc_s, &target_outcome, 0);

	CRM_ASSERT(fake_cib->cmds->query(fake_cib, NULL, NULL,
	cib_sync_call) == pcmk_ok);

	// Ensure the action node is in the CIB
	uuid = crm_element_value_copy(action->xml, PCMK__META_ON_NODE_UUID);
	cib_node = pcmk__inject_node(fake_cib, node,
	((router_node == NULL)? uuid: node));
	free(uuid);
	CRM_ASSERT(cib_node != NULL);

	// Add a history entry for the action
	cib_resource = pcmk__inject_resource_history(out, cib_node, resource,
	resource_config_name,
	rclass, rtype, rprovider);
	if (cib_resource == NULL) {
	crm_err("Could not simulate action %d history for resource %s",
	action->id, resource);
	free(node);
	pcmk__xml_free(cib_node);
	return EINVAL;
	}

	// Simulate and display an executor event for the action result
	op = pcmk__event_from_graph_action(cib_resource, action, PCMK_EXEC_DONE,
	target_outcome, "User-injected result");
	out->message(out, "inject-rsc-action", resource, op->op_type, node,
	op->interval_ms);

	// Check whether action is in a list of desired simulated failures
	for (const GList *iter = fake_op_fail_list;
	iter != NULL; iter = iter->next) {
	const char spec = (const char ) iter->data;
	char *key = NULL;
	const char *match_name = NULL;

	// Allow user to specify anonymous clone with or without instance number
	key = crm_strdup_printf(PCMK__OP_FMT "@%s=", resource, op->op_type,
	op->interval_ms, node);
	if (strncasecmp(key, spec, strlen(key)) == 0) {
	match_name = resource;
	}
	free(key);

	// If not found, try the resource's name in the configuration
	if ((match_name == NULL)
	&& (strcmp(resource, resource_config_name) != 0)) {

	key = crm_strdup_printf(PCMK__OP_FMT "@%s=", resource_config_name,
	op->op_type, op->interval_ms, node);
	if (strncasecmp(key, spec, strlen(key)) == 0) {
	match_name = resource_config_name;
	}
	free(key);
	}

	if (match_name == NULL) {
	continue; // This failed action entry doesn't match
	}

	// ${match_name}_${task}_${interval_in_ms}@${node}=${rc}
	rc = sscanf(spec, "%[^=]=%d", (int ) &op->rc);
	if (rc != 1) {
	out->err(out, "Invalid failed operation '%s' "
	"(result code must be integer)", spec);
	continue; // Keep checking other list entries
	}

	out->info(out, "Pretending action %d failed with rc=%d",
	action->id, op->rc);
	pcmk__set_graph_action_flags(action, pcmk__graph_action_failed);
	graph->abort_priority = PCMK_SCORE_INFINITY;
	pcmk__inject_failcount(out, fake_cib, cib_node, match_name, op->op_type,
	op->interval_ms, op->rc);
	break;
	}

	pcmk__inject_action_result(cib_resource, op, node, target_outcome);
	lrmd_free_event(op);
	rc = fake_cib->cmds->modify(fake_cib, PCMK_XE_STATUS, cib_node,
	cib_sync_call);
	CRM_ASSERT(rc == pcmk_ok);

	done:
	free(node);
	pcmk__xml_free(cib_node);
	pcmk__set_graph_action_flags(action, pcmk__graph_action_confirmed);
	pcmk__update_graph(graph, action);
	return pcmk_rc_ok;
	}

	/*!
	* \internal
	* \brief Simulate successfully executing a cluster action
	*
	* \param[in,out] graph Graph to update with action result
	* \param[in,out] action Cluster action to simulate
	*
	* \return Standard Pacemaker return code
	*/
	static int
	simulate_cluster_action(pcmk__graph_t graph, pcmk__graph_action_t action)
	{
	const char *node = crm_element_value(action->xml, PCMK__META_ON_NODE);
	const char *task = crm_element_value(action->xml, PCMK_XA_OPERATION);
	xmlNode *rsc = pcmk__xe_first_child(action->xml, PCMK_XE_PRIMITIVE, NULL,
	NULL);

	pcmk__set_graph_action_flags(action, pcmk__graph_action_confirmed);
	out->message(out, "inject-cluster-action", node, task, rsc);
	pcmk__update_graph(graph, action);
	return pcmk_rc_ok;
	}

	/*!
	* \internal
	* \brief Simulate successfully executing a fencing action
	*
	* \param[in,out] graph Graph to update with action result
	* \param[in,out] action Fencing action to simulate
	*
	* \return Standard Pacemaker return code
	*/
	static int
	simulate_fencing_action(pcmk__graph_t graph, pcmk__graph_action_t action)
	{
	const char *op = crm_meta_value(action->params, PCMK__META_STONITH_ACTION);
	char *target = crm_element_value_copy(action->xml, PCMK__META_ON_NODE);

	out->message(out, "inject-fencing-action", target, op);

	if (!pcmk__str_eq(op, PCMK_ACTION_ON, pcmk__str_casei)) {
	int rc = pcmk_ok;
	GString *xpath = g_string_sized_new(512);

	// Set node state to offline
	xmlNode *cib_node = pcmk__inject_node_state_change(fake_cib, target,
	false);

	CRM_ASSERT(cib_node != NULL);
	crm_xml_add(cib_node, PCMK_XA_CRM_DEBUG_ORIGIN, __func__);
	rc = fake_cib->cmds->replace(fake_cib, PCMK_XE_STATUS, cib_node,
	cib_sync_call);
	CRM_ASSERT(rc == pcmk_ok);

	// Simulate controller clearing node's resource history and attributes
	pcmk__g_strcat(xpath,
	"//" PCMK__XE_NODE_STATE
	"[@" PCMK_XA_UNAME "='", target, "']/" PCMK__XE_LRM,
	NULL);
	fake_cib->cmds->remove(fake_cib, (const char *) xpath->str, NULL,
	cib_xpath\|cib_sync_call);

	g_string_truncate(xpath, 0);
	pcmk__g_strcat(xpath,
	"//" PCMK__XE_NODE_STATE
	"[@" PCMK_XA_UNAME "='", target, "']"
	"/" PCMK__XE_TRANSIENT_ATTRIBUTES, NULL);
	fake_cib->cmds->remove(fake_cib, (const char *) xpath->str, NULL,
	cib_xpath\|cib_sync_call);

	pcmk__xml_free(cib_node);
	g_string_free(xpath, TRUE);
	}

	pcmk__set_graph_action_flags(action, pcmk__graph_action_confirmed);
	pcmk__update_graph(graph, action);
	free(target);
	return pcmk_rc_ok;
	}

	enum pcmk__graph_status
	pcmk__simulate_transition(pcmk_scheduler_t scheduler, cib_t cib,
	const GList *op_fail_list)
	{
	pcmk__graph_t *transition = NULL;
	enum pcmk__graph_status graph_rc;

	pcmk__graph_functions_t simulation_fns = {
	simulate_pseudo_action,
	simulate_resource_action,
	simulate_cluster_action,
	simulate_fencing_action,
	};

	out = scheduler->priv->out;

	fake_cib = cib;
	fake_op_fail_list = op_fail_list;

	if (!out->is_quiet(out)) {
	out->begin_list(out, NULL, NULL, "Executing Cluster Transition");
	}

	pcmk__set_graph_functions(&simulation_fns);
	transition = pcmk__unpack_graph(scheduler->priv->graph, crm_system_name);
	pcmk__log_graph(LOG_DEBUG, transition);

	fake_resource_list = scheduler->priv->resources;
	do {
	graph_rc = pcmk__execute_graph(transition);
	} while (graph_rc == pcmk__graph_active);
	fake_resource_list = NULL;

	if (graph_rc != pcmk__graph_complete) {
	out->err(out, "Transition failed: %s",
	pcmk__graph_status2text(graph_rc));
	pcmk__log_graph(LOG_ERR, transition);
	out->err(out, "An invalid transition was produced");
	}
	pcmk__free_graph(transition);

	if (!out->is_quiet(out)) {
	// If not quiet, we'll need the resulting CIB for later display
	xmlNode *cib_object = NULL;
	int rc = fake_cib->cmds->query(fake_cib, NULL, &cib_object,
	cib_sync_call);

	CRM_ASSERT(rc == pcmk_ok);
	pe_reset_working_set(scheduler);
	scheduler->input = cib_object;
	out->end_list(out);
	}
	return graph_rc;
	}

	int
	pcmk__simulate(pcmk_scheduler_t scheduler, pcmk__output_t out,
	const pcmk_injections_t *injections, unsigned int flags,
	uint32_t section_opts, const char *use_date,
	const char input_file, const char graph_file,
	const char *dot_file)
	{
	int printed = pcmk_rc_no_output;
	int rc = pcmk_rc_ok;
	xmlNodePtr input = NULL;
	cib_t *cib = NULL;

	rc = cib__signon_query(out, &cib, &input);
	if (rc != pcmk_rc_ok) {
	goto simulate_done;
	}

	reset(scheduler, input, out, use_date, flags);
	cluster_status(scheduler);

	if (!out->is_quiet(out)) {
	const bool show_pending = pcmk_is_set(flags, pcmk_sim_show_pending);

	if (pcmk_is_set(scheduler->flags, pcmk__sched_in_maintenance)) {
	printed = out->message(out, "maint-mode", scheduler->flags);
	}

	if ((scheduler->priv->disabled_resources > 0)
	\|\| (scheduler->priv->blocked_resources > 0)) {

	PCMK__OUTPUT_SPACER_IF(out, printed == pcmk_rc_ok);
	printed = out->info(out,
	"%d of %d resource instances DISABLED and "
	"%d BLOCKED from further action due to failure",
	scheduler->priv->disabled_resources,
	scheduler->priv->ninstances,
	scheduler->priv->blocked_resources);
	}

	/* Most formatted output headers use caps for each word, but this one
	* only has the first word capitalized for compatibility with pcs.
	*/
	print_cluster_status(scheduler, (show_pending? pcmk_show_pending : 0),
	section_opts, "Current cluster status",
	(printed == pcmk_rc_ok));
	printed = pcmk_rc_ok;
	}

	// If the user requested any injections, handle them
	if ((injections->node_down != NULL)
	\|\| (injections->node_fail != NULL)
	\|\| (injections->node_up != NULL)
	\|\| (injections->op_inject != NULL)
	\|\| (injections->ticket_activate != NULL)
	\|\| (injections->ticket_grant != NULL)
	\|\| (injections->ticket_revoke != NULL)
	\|\| (injections->ticket_standby != NULL)
	\|\| (injections->watchdog != NULL)) {

	PCMK__OUTPUT_SPACER_IF(out, printed == pcmk_rc_ok);
	pcmk__inject_scheduler_input(scheduler, cib, injections);
	printed = pcmk_rc_ok;

	rc = cib->cmds->query(cib, NULL, &input, cib_sync_call);
	if (rc != pcmk_rc_ok) {
	rc = pcmk_legacy2rc(rc);
	goto simulate_done;
	}

	cleanup_calculations(scheduler);
	reset(scheduler, input, out, use_date, flags);
	cluster_status(scheduler);
	}

	if (input_file != NULL) {
	rc = pcmk__xml_write_file(input, input_file, false);
	if (rc != pcmk_rc_ok) {
	goto simulate_done;
	}
	}

	if (pcmk_any_flags_set(flags, pcmk_sim_process \| pcmk_sim_simulate)) {
	pcmk__output_t *logger_out = NULL;
	unsigned long long scheduler_flags = pcmk__sched_none;

	if (pcmk_is_set(scheduler->flags, pcmk__sched_output_scores)) {
	scheduler_flags \|= pcmk__sched_output_scores;
	}
	if (pcmk_is_set(scheduler->flags, pcmk__sched_show_utilization)) {
	scheduler_flags \|= pcmk__sched_show_utilization;
	}

	if (pcmk_all_flags_set(scheduler->flags,
	pcmk__sched_output_scores
	\|pcmk__sched_show_utilization)) {
	PCMK__OUTPUT_SPACER_IF(out, printed == pcmk_rc_ok);
	out->begin_list(out, NULL, NULL,
	"Assignment Scores and Utilization Information");
	printed = pcmk_rc_ok;

	} else if (pcmk_is_set(scheduler->flags, pcmk__sched_output_scores)) {
	PCMK__OUTPUT_SPACER_IF(out, printed == pcmk_rc_ok);
	out->begin_list(out, NULL, NULL, "Assignment Scores");
	printed = pcmk_rc_ok;

	} else if (pcmk_is_set(scheduler->flags, pcmk__sched_show_utilization)) {
	PCMK__OUTPUT_SPACER_IF(out, printed == pcmk_rc_ok);
	out->begin_list(out, NULL, NULL, "Utilization Information");
	printed = pcmk_rc_ok;

	} else {
	rc = pcmk__log_output_new(&logger_out);
	if (rc != pcmk_rc_ok) {
	goto simulate_done;
	}
	pe__register_messages(logger_out);
	pcmk__register_lib_messages(logger_out);
	scheduler->priv->out = logger_out;
	}

	pcmk__schedule_actions(input, scheduler_flags, scheduler);

	if (logger_out == NULL) {
	out->end_list(out);
	} else {
	logger_out->finish(logger_out, CRM_EX_OK, true, NULL);
	pcmk__output_free(logger_out);
	scheduler->priv->out = out;
	}

	input = NULL; /* Don't try and free it twice */

	if (graph_file != NULL) {
	rc = pcmk__xml_write_file(scheduler->priv->graph, graph_file,
	false);
	if (rc != pcmk_rc_ok) {
	rc = pcmk_rc_graph_error;
	goto simulate_done;
	}
	}

	if (dot_file != NULL) {
	rc = write_sim_dotfile(scheduler, dot_file,
	pcmk_is_set(flags, pcmk_sim_all_actions),
	pcmk_is_set(flags, pcmk_sim_verbose));
	if (rc != pcmk_rc_ok) {
	rc = pcmk_rc_dot_error;
	goto simulate_done;
	}
	}

	if (!out->is_quiet(out)) {
	print_transition_summary(scheduler, printed == pcmk_rc_ok);
	}
	}

	rc = pcmk_rc_ok;

	if (!pcmk_is_set(flags, pcmk_sim_simulate)) {
	goto simulate_done;
	}

	PCMK__OUTPUT_SPACER_IF(out, printed == pcmk_rc_ok);
	if (pcmk__simulate_transition(scheduler, cib, injections->op_fail)
	!= pcmk__graph_complete) {
	rc = pcmk_rc_invalid_transition;
	}

	if (out->is_quiet(out)) {
	goto simulate_done;
	}

	set_effective_date(scheduler, true, use_date);

	if (pcmk_is_set(flags, pcmk_sim_show_scores)) {
	pcmk__set_scheduler_flags(scheduler, pcmk__sched_output_scores);
	}
	if (pcmk_is_set(flags, pcmk_sim_show_utilization)) {
	pcmk__set_scheduler_flags(scheduler, pcmk__sched_show_utilization);
	}

	cluster_status(scheduler);
	print_cluster_status(scheduler, 0, section_opts, "Revised Cluster Status",
	true);

	simulate_done:
	cib__clean_up_connection(&cib);
	return rc;
	}

	int
	pcmk_simulate(xmlNodePtr xml, pcmk_scheduler_t scheduler,
	const pcmk_injections_t *injections, unsigned int flags,
	unsigned int section_opts, const char *use_date,
	const char input_file, const char graph_file,
	const char *dot_file)
	{
	pcmk__output_t *out = NULL;
	int rc = pcmk_rc_ok;

	rc = pcmk__xml_output_new(&out, xml);
	if (rc != pcmk_rc_ok) {
	return rc;
	}

	pe__register_messages(out);
	pcmk__register_lib_messages(out);

	rc = pcmk__simulate(scheduler, out, injections, flags, section_opts,
	use_date, input_file, graph_file, dot_file);
	pcmk__xml_output_finish(out, pcmk_rc2exitc(rc), xml);
	return rc;
	}
	diff --git a/lib/pacemaker/pcmk_status.c b/lib/pacemaker/pcmk_status.c
	index c07adbfb64..002817c06a 100644
	--- a/lib/pacemaker/pcmk_status.c
	+++ b/lib/pacemaker/pcmk_status.c
	@@ -1,283 +1,283 @@
	/*
	* 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 <stddef.h>
	#include <stdint.h>

	#include <crm/cib/internal.h>
	#include <crm/common/output.h>
	#include <crm/common/results.h>
	#include <crm/fencing/internal.h>
	#include <crm/pengine/internal.h>
	#include <crm/stonith-ng.h> // stonith__register_messages()
	#include <pacemaker.h>
	#include <pacemaker-internal.h>

	static stonith_t *
	fencing_connect(void)
	{
	stonith_t *st = stonith_api_new();
	int rc = pcmk_rc_ok;

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

	rc = st->cmds->connect(st, crm_system_name, NULL);
	if (rc == pcmk_rc_ok) {
	return st;
	} else {
	stonith_api_delete(st);
	return NULL;
	}
	}

	/*!
	* \internal
	* \brief Output the cluster status given a fencer and CIB connection
	*
	* \param[in,out] scheduler Scheduler object (will be reset)
	* \param[in,out] stonith Fencer connection
	* \param[in,out] cib CIB connection
	* \param[in] current_cib Current CIB XML
	* \param[in] pcmkd_state \p pacemakerd state
	* \param[in] fence_history How much of the fencing history to output
	* \param[in] show Group of \p pcmk_section_e flags
	* \param[in] show_opts Group of \p pcmk_show_opt_e flags
	* \param[in] only_node If a node name or tag, include only the
	* matching node(s) (if any) in the output.
	* If \p "*" or \p NULL, include all nodes
	* in the output.
	* \param[in] only_rsc If a resource ID or tag, include only the
	* matching resource(s) (if any) in the
	* output. If \p "*" or \p NULL, include all
	* resources in the output.
	* \param[in] neg_location_prefix Prefix denoting a ban in a constraint ID
	*
	* \return Standard Pacemaker return code
	*/
	int
	pcmk__output_cluster_status(pcmk_scheduler_t scheduler, stonith_t stonith,
	cib_t cib, xmlNode current_cib,
	enum pcmk_pacemakerd_state pcmkd_state,
	enum pcmk__fence_history fence_history,
	uint32_t show, uint32_t show_opts,
	const char only_node, const char only_rsc,
	const char *neg_location_prefix)
	{
	xmlNode *cib_copy = pcmk__xml_copy(NULL, current_cib);
	stonith_history_t *stonith_history = NULL;
	int history_rc = 0;
	GList *unames = NULL;
	GList *resources = NULL;
	pcmk__output_t *out = NULL;

	int rc = pcmk_rc_ok;

	if ((scheduler == NULL) \|\| (scheduler->priv->out == NULL)) {
	return EINVAL;
	}
	out = scheduler->priv->out;

	- rc = pcmk_update_configured_schema(&cib_copy, false);
	+ rc = pcmk__update_configured_schema(&cib_copy, false);
	if (rc != pcmk_rc_ok) {
	cib__clean_up_connection(&cib);
	pcmk__xml_free(cib_copy);
	out->err(out, "Upgrade failed: %s", pcmk_rc_str(rc));
	return rc;
	}

	/* get the stonith-history if there is evidence we need it */
	if (fence_history != pcmk__fence_history_none) {
	history_rc = pcmk__get_fencing_history(stonith, &stonith_history,
	fence_history);
	}

	pe_reset_working_set(scheduler);
	scheduler->input = cib_copy;
	cluster_status(scheduler);

	/* Unpack constraints if any section will need them
	* (tickets may be referenced in constraints but not granted yet,
	* and bans need negative location constraints) */
	if (pcmk_is_set(show, pcmk_section_bans)
	\|\| pcmk_is_set(show, pcmk_section_tickets)) {
	pcmk__unpack_constraints(scheduler);
	}

	unames = pe__build_node_name_list(scheduler, only_node);
	resources = pe__build_rsc_list(scheduler, only_rsc);

	/* Always print DC if NULL. */
	if (scheduler->dc_node == NULL) {
	show \|= pcmk_section_dc;
	}

	out->message(out, "cluster-status",
	scheduler, pcmkd_state, pcmk_rc2exitc(history_rc),
	stonith_history, fence_history, show, show_opts,
	neg_location_prefix, unames, resources);

	g_list_free_full(unames, free);
	g_list_free_full(resources, free);

	stonith_history_free(stonith_history);
	stonith_history = NULL;
	return rc;
	}

	int
	pcmk_status(xmlNodePtr *xml)
	{
	cib_t *cib = NULL;
	pcmk__output_t *out = NULL;
	int rc = pcmk_rc_ok;

	uint32_t show_opts = pcmk_show_pending
	\|pcmk_show_inactive_rscs
	\|pcmk_show_timing;

	cib = cib_new();

	if (cib == NULL) {
	return pcmk_rc_cib_corrupt;
	}

	rc = pcmk__xml_output_new(&out, xml);
	if (rc != pcmk_rc_ok) {
	cib_delete(cib);
	return rc;
	}

	pcmk__register_lib_messages(out);
	pe__register_messages(out);
	stonith__register_messages(out);

	rc = pcmk__status(out, cib, pcmk__fence_history_full, pcmk_section_all,
	show_opts, NULL, NULL, NULL, 0);
	pcmk__xml_output_finish(out, pcmk_rc2exitc(rc), xml);

	cib_delete(cib);
	return rc;
	}

	/*!
	* \internal
	* \brief Query and output the cluster status
	*
	* The operation is considered a success if we're able to get the \p pacemakerd
	* state. If possible, we'll also try to connect to the fencer and CIB and
	* output their respective status information.
	*
	* \param[in,out] out Output object
	* \param[in,out] cib CIB connection
	* \param[in] fence_history How much of the fencing history to output
	* \param[in] show Group of \p pcmk_section_e flags
	* \param[in] show_opts Group of \p pcmk_show_opt_e flags
	* \param[in] only_node If a node name or tag, include only the
	* matching node(s) (if any) in the output.
	* If \p "*" or \p NULL, include all nodes
	* in the output.
	* \param[in] only_rsc If a resource ID or tag, include only the
	* matching resource(s) (if any) in the
	* output. If \p "*" or \p NULL, include all
	* resources in the output.
	* \param[in] neg_location_prefix Prefix denoting a ban in a constraint ID
	* \param[in] timeout_ms How long to wait for a reply from the
	* \p pacemakerd API. If 0,
	* \p pcmk_ipc_dispatch_sync will be used.
	* If positive, \p pcmk_ipc_dispatch_main
	* will be used, and a new mainloop will be
	* created for this purpose (freed before
	* return).
	*
	* \return Standard Pacemaker return code
	*/
	int
	pcmk__status(pcmk__output_t out, cib_t cib,
	enum pcmk__fence_history fence_history, uint32_t show,
	uint32_t show_opts, const char only_node, const char only_rsc,
	const char *neg_location_prefix, unsigned int timeout_ms)
	{
	xmlNode *current_cib = NULL;
	int rc = pcmk_rc_ok;
	stonith_t *stonith = NULL;
	enum pcmk_pacemakerd_state pcmkd_state = pcmk_pacemakerd_state_invalid;
	time_t last_updated = 0;
	pcmk_scheduler_t *scheduler = NULL;

	if (cib == NULL) {
	return ENOTCONN;
	}

	if (cib->variant == cib_native) {
	rc = pcmk__pacemakerd_status(out, crm_system_name, timeout_ms, false,
	&pcmkd_state);
	if (rc != pcmk_rc_ok) {
	return rc;
	}

	last_updated = time(NULL);

	switch (pcmkd_state) {
	case pcmk_pacemakerd_state_running:
	case pcmk_pacemakerd_state_shutting_down:
	case pcmk_pacemakerd_state_remote:
	/* Fencer and CIB may still be available while shutting down or
	* running on a Pacemaker Remote node
	*/
	break;
	default:
	// Fencer and CIB are definitely unavailable
	out->message(out, "pacemakerd-health",
	NULL, pcmkd_state, NULL, last_updated);
	return rc;
	}

	if (fence_history != pcmk__fence_history_none) {
	stonith = fencing_connect();
	}
	}

	rc = cib__signon_query(out, &cib, &current_cib);
	if (rc != pcmk_rc_ok) {
	if (pcmkd_state != pcmk_pacemakerd_state_invalid) {
	// Invalid at this point means we didn't query the pcmkd state
	out->message(out, "pacemakerd-health",
	NULL, pcmkd_state, NULL, last_updated);
	}
	goto done;
	}

	scheduler = pe_new_working_set();
	pcmk__mem_assert(scheduler);
	scheduler->priv->out = out;

	if ((cib->variant == cib_native) && pcmk_is_set(show, pcmk_section_times)) {
	// Currently used only in the times section
	pcmk__query_node_name(out, 0, &(scheduler->priv->local_node_name), 0);
	}

	rc = pcmk__output_cluster_status(scheduler, stonith, cib, current_cib,
	pcmkd_state, fence_history, show,
	show_opts, only_node, only_rsc,
	neg_location_prefix);
	if (rc != pcmk_rc_ok) {
	out->err(out, "Error outputting status info from the fencer or CIB");
	}

	done:
	pe_free_working_set(scheduler);
	stonith_api_delete(stonith);
	pcmk__xml_free(current_cib);
	return pcmk_rc_ok;
	}
	diff --git a/lib/pacemaker/pcmk_verify.c b/lib/pacemaker/pcmk_verify.c
	index 39807ccbea..f7433277c1 100644
	--- a/lib/pacemaker/pcmk_verify.c
	+++ b/lib/pacemaker/pcmk_verify.c
	@@ -1,157 +1,157 @@
	/*
	* Copyright 2023-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 <crm/cib/internal.h>
	#include <crm/common/output.h>
	#include <crm/common/results.h>
	#include <crm/common/scheduler.h>
	#include <pacemaker-internal.h>
	#include <pacemaker.h>

	#include <stdint.h>
	#include <sys/types.h>
	#include <sys/stat.h>
	#include <unistd.h>

	#include "libpacemaker_private.h"

	int
	pcmk__parse_cib(pcmk__output_t out, const char cib_source, xmlNodePtr *cib_object)
	{
	// @COMPAT Take an enum for cib_source instead of trying to figure it out?
	const char *first = cib_source;

	if (cib_source == NULL) {
	crm_info("Reading XML from: live cluster");
	return cib__signon_query(out, NULL, cib_object);
	}

	while (isspace(*first)) {
	first++;
	}

	if (*first == '<') {
	*cib_object = pcmk__xml_parse(cib_source);
	} else {
	*cib_object = pcmk__xml_read(cib_source);
	}

	return (*cib_object == NULL)? ENODATA : pcmk_rc_ok;
	}

	int
	pcmk__verify(pcmk_scheduler_t scheduler, pcmk__output_t out,
	xmlNode **cib_object)
	{
	int rc = pcmk_rc_ok;
	xmlNode *status = NULL;
	xmlNode *cib_object_copy = NULL;

	CRM_ASSERT(cib_object != NULL);

	if (!pcmk__xe_is(*cib_object, PCMK_XE_CIB)) {
	rc = EBADMSG;
	out->err(out, "This tool can only check complete configurations (i.e. those starting with <cib>).");
	goto verify_done;
	}

	status = pcmk_find_cib_element(*cib_object, PCMK_XE_STATUS);
	if (status == NULL) {
	pcmk__xe_create(*cib_object, PCMK_XE_STATUS);
	}

	if (!pcmk__validate_xml(*cib_object, NULL,
	(xmlRelaxNGValidityErrorFunc) out->err, out)) {
	pcmk__config_has_error = true;
	rc = pcmk_rc_schema_validation;
	goto verify_done;
	}

	- rc = pcmk_update_configured_schema(cib_object, false);
	+ rc = pcmk__update_configured_schema(cib_object, false);
	if (rc != pcmk_rc_ok) {
	pcmk__config_has_error = true;
	out->err(out, "The cluster will NOT be able to use this configuration.\n"
	"Please manually update the configuration to conform to the %s syntax.",
	pcmk__highest_schema_name());
	goto verify_done;
	}

	/* Process the configuration to set pcmk__config_has_error and
	* pcmk__config_has_warning.
	*
	* @TODO Some parts of the configuration are unpacked only when needed (for
	* example, action configuration), so we aren't necessarily checking those.
	*/
	if (*cib_object != NULL) {
	unsigned long long flags = pcmk__sched_no_counts;

	if (status == NULL) {
	// No status available, so do minimal checks
	flags \|= pcmk__sched_validate_only;
	}
	cib_object_copy = pcmk__xml_copy(NULL, *cib_object);

	/* The scheduler takes ownership of the XML object and potentially
	* frees it later. We want the caller of pcmk__verify to retain
	* ownership of the passed-in XML object, hence we pass in a copy
	* to the scheduler.
	*/
	pcmk__schedule_actions(cib_object_copy, flags, scheduler);
	}

	verify_done:
	if (pcmk__config_has_error) {
	rc = pcmk_rc_schema_validation;
	pcmk__config_err("CIB did not pass schema validation");
	} else if (pcmk__config_has_warning) {
	rc = pcmk_rc_schema_validation;
	}
	return rc;
	}

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

	xmlNode *cib_object = NULL;

	rc = pcmk__xml_output_new(&out, xml);
	if (rc != pcmk_rc_ok) {
	return rc;
	}

	pe__register_messages(out);
	pcmk__register_lib_messages(out);

	rc = pcmk__parse_cib(out, cib_source, &cib_object);
	if (rc != pcmk_rc_ok) {
	out->err(out, "Couldn't parse input");
	goto done;
	}

	scheduler = pe_new_working_set();
	if (scheduler == NULL) {
	rc = errno;
	out->err(out, "Couldn't allocate scheduler data: %s", pcmk_rc_str(rc));
	goto done;
	}

	scheduler->priv->out = out;
	rc = pcmk__verify(scheduler, out, &cib_object);

	done:
	pe_free_working_set(scheduler);
	pcmk__xml_output_finish(out, pcmk_rc2exitc(rc), xml);
	pcmk__xml_free(cib_object);
	return rc;
	}
	diff --git a/tools/crm_resource_runtime.c b/tools/crm_resource_runtime.c
	index b2fb6cb4b7..105a591fc5 100644
	--- a/tools/crm_resource_runtime.c
	+++ b/tools/crm_resource_runtime.c
	@@ -1,2434 +1,2434 @@
	/*
	* 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 <stdio.h>
	#include <limits.h>
	#include <glib.h>
	#include <libxml/tree.h>

	#include <crm/common/ipc_attrd_internal.h>
	#include <crm/common/ipc_controld.h>
	#include <crm/common/lists_internal.h>
	#include <crm/services_internal.h>

	#include <crm_resource.h>

	static GList *
	build_node_info_list(const pcmk_resource_t *rsc)
	{
	GList *retval = NULL;

	for (const GList *iter = rsc->priv->children;
	iter != NULL; iter = iter->next) {

	const pcmk_resource_t child = (const pcmk_resource_t ) iter->data;

	for (const GList *iter2 = child->priv->active_nodes;
	iter2 != NULL; iter2 = iter2->next) {

	const pcmk_node_t node = (const pcmk_node_t ) iter2->data;
	node_info_t *ni = pcmk__assert_alloc(1, sizeof(node_info_t));

	ni->node_name = node->priv->name;
	if (pcmk_is_set(rsc->flags, pcmk__rsc_promotable)
	&& (child->priv->fns->state(child,
	TRUE) == pcmk_role_promoted)) {
	ni->promoted = true;
	}

	retval = g_list_prepend(retval, ni);
	}
	}

	return retval;
	}

	GList *
	cli_resource_search(pcmk_resource_t rsc, const char requested_name,
	pcmk_scheduler_t *scheduler)
	{
	GList *retval = NULL;
	const pcmk_resource_t *parent = pe__const_top_resource(rsc, false);

	if (pcmk__is_clone(rsc)) {
	retval = build_node_info_list(rsc);

	/* The anonymous clone children's common ID is supplied */
	} else if (pcmk__is_clone(parent)
	&& !pcmk_is_set(rsc->flags, pcmk__rsc_unique)
	&& (rsc->priv->history_id != NULL)
	&& pcmk__str_eq(requested_name, rsc->priv->history_id,
	pcmk__str_none)
	&& !pcmk__str_eq(requested_name, rsc->id, pcmk__str_none)) {

	retval = build_node_info_list(parent);

	} else {
	for (GList *iter = rsc->priv->active_nodes;
	iter != NULL; iter = iter->next) {

	pcmk_node_t node = (pcmk_node_t ) iter->data;
	node_info_t *ni = pcmk__assert_alloc(1, sizeof(node_info_t));

	ni->node_name = node->priv->name;
	if (rsc->priv->fns->state(rsc, TRUE) == pcmk_role_promoted) {
	ni->promoted = true;
	}

	retval = g_list_prepend(retval, ni);
	}
	}

	return retval;
	}

	// \return Standard Pacemaker return code
	static int
	find_resource_attr(pcmk__output_t out, cib_t the_cib, const char *attr,
	const char rsc, const char attr_set_type, const char *set_name,
	const char attr_id, const char attr_name, xmlNode **result)
	{
	xmlNode *xml_search;
	int rc = pcmk_rc_ok;
	GString *xpath = NULL;
	const char *xpath_base = NULL;

	if (result) {
	*result = NULL;
	}

	if(the_cib == NULL) {
	return ENOTCONN;
	}

	xpath_base = pcmk_cib_xpath_for(PCMK_XE_RESOURCES);
	if (xpath_base == NULL) {
	crm_err(PCMK_XE_RESOURCES " CIB element not known (bug?)");
	return ENOMSG;
	}

	xpath = g_string_sized_new(1024);
	pcmk__g_strcat(xpath,
	xpath_base, "//*[@" PCMK_XA_ID "=\"", rsc, "\"]", NULL);

	if (attr_set_type != NULL) {
	pcmk__g_strcat(xpath, "/", attr_set_type, NULL);
	if (set_name != NULL) {
	pcmk__g_strcat(xpath, "[@" PCMK_XA_ID "=\"", set_name, "\"]",
	NULL);
	}
	}

	g_string_append(xpath, "//" PCMK_XE_NVPAIR);

	if (attr_id != NULL && attr_name!= NULL) {
	pcmk__g_strcat(xpath,
	"[@" PCMK_XA_ID "='", attr_id, "' "
	"and @" PCMK_XA_NAME "='", attr_name, "']", NULL);

	} else if (attr_id != NULL) {
	pcmk__g_strcat(xpath, "[@" PCMK_XA_ID "='", attr_id, "']", NULL);

	} else if (attr_name != NULL) {
	pcmk__g_strcat(xpath, "[@" PCMK_XA_NAME "='", attr_name, "']", NULL);
	}

	rc = the_cib->cmds->query(the_cib, xpath->str, &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) {
	rc = ENOTUNIQ;
	pcmk__warn_multiple_name_matches(out, xml_search, attr_name);
	out->spacer(out);
	}
	}

	if (result) {
	*result = xml_search;
	} else {
	pcmk__xml_free(xml_search);
	}

	g_string_free(xpath, TRUE);
	return rc;
	}

	/* PRIVATE. Use the find_matching_attr_resources instead. */
	static void
	find_matching_attr_resources_recursive(pcmk__output_t *out,
	GList /* <pcmk_resource_t> / **result,
	pcmk_resource_t rsc, const char attr_set,
	const char * attr_set_type, const char * attr_id,
	const char * attr_name, cib_t * cib, int depth)
	{
	int rc = pcmk_rc_ok;
	char *lookup_id = clone_strip(rsc->id);

	for (GList *gIter = rsc->priv->children;
	gIter != NULL; gIter = gIter->next) {

	find_matching_attr_resources_recursive(out, result,
	(pcmk_resource_t *) gIter->data,
	attr_set, attr_set_type, attr_id,
	attr_name, cib, depth+1);
	/* do it only once for clones */
	if (pcmk__is_clone(rsc)) {
	break;
	}
	}

	rc = find_resource_attr(out, cib, PCMK_XA_ID, lookup_id, attr_set_type,
	attr_set, attr_id, attr_name, NULL);
	/* Post-order traversal.
	* The root is always on the list and it is the last item. */
	if((0 == depth) \|\| (pcmk_rc_ok == rc)) {
	/* push the head */
	result = g_list_append(result, rsc);
	}

	free(lookup_id);
	}


	/* The result is a linearized pre-ordered tree of resources. */
	static GList/<pcmk_resource_t>/
	find_matching_attr_resources(pcmk__output_t out, pcmk_resource_t rsc,
	const char * rsc_id, const char * attr_set,
	const char * attr_set_type, const char * attr_id,
	const char * attr_name, cib_t * cib, const char * cmd,
	gboolean force)
	{
	int rc = pcmk_rc_ok;
	char *lookup_id = NULL;
	GList * result = NULL;

	/* If --force is used, update only the requested resource (clone or primitive).
	* Otherwise, if the primitive has the attribute, use that.
	* Otherwise use the clone. */
	if(force == TRUE) {
	return g_list_append(result, rsc);
	}
	if (pcmk__is_clone(rsc->priv->parent)) {
	int rc = find_resource_attr(out, cib, PCMK_XA_ID, rsc_id, attr_set_type,
	attr_set, attr_id, attr_name, NULL);

	if(rc != pcmk_rc_ok) {
	rsc = rsc->priv->parent;
	out->info(out, "Performing %s of '%s' on '%s', the parent of '%s'",
	cmd, attr_name, rsc->id, rsc_id);
	}
	return g_list_append(result, rsc);

	} else if ((rsc->priv->parent == NULL)
	&& (rsc->priv->children != NULL) && pcmk__is_clone(rsc)) {

	pcmk_resource_t *child = rsc->priv->children->data;

	if (pcmk__is_primitive(child)) {
	lookup_id = clone_strip(child->id); /* Could be a cloned group! */
	rc = find_resource_attr(out, cib, PCMK_XA_ID, lookup_id,
	attr_set_type, attr_set, attr_id, attr_name, NULL);

	if(rc == pcmk_rc_ok) {
	rsc = child;
	out->info(out, "A value for '%s' already exists in child '%s', performing %s on that instead of '%s'",
	attr_name, lookup_id, cmd, rsc_id);
	}

	free(lookup_id);
	}
	return g_list_append(result, rsc);
	}
	/* If the resource is a group ==> children inherit the attribute if defined. */
	find_matching_attr_resources_recursive(out, &result, rsc, attr_set,
	attr_set_type, attr_id, attr_name,
	cib, 0);
	return result;
	}

	static int
	update_element_attribute(pcmk__output_t out, pcmk_resource_t rsc,
	cib_t cib, const char attr_name, const char *attr_value)
	{
	int rc = pcmk_rc_ok;

	if (cib == NULL) {
	return ENOTCONN;
	}

	crm_xml_add(rsc->priv->xml, attr_name, attr_value);

	rc = cib->cmds->replace(cib, PCMK_XE_RESOURCES, rsc->priv->xml,
	cib_sync_call);
	rc = pcmk_legacy2rc(rc);
	if (rc == pcmk_rc_ok) {
	out->info(out, "Set attribute: " PCMK_XA_NAME "=%s value=%s",
	attr_name, attr_value);
	}

	return rc;
	}

	static int
	resources_with_attr(pcmk__output_t out, cib_t cib, pcmk_resource_t *rsc,
	const char requested_name, const char attr_set,
	const char attr_set_type, const char attr_id,
	const char attr_name, const char top_id, gboolean force,
	GList **resources)
	{
	if (pcmk__str_eq(attr_set_type, PCMK_XE_INSTANCE_ATTRIBUTES,
	pcmk__str_casei)) {
	if (!force) {
	xmlNode *xml_search = NULL;
	int rc = pcmk_rc_ok;

	rc = find_resource_attr(out, cib, PCMK_XA_ID, top_id,
	PCMK_XE_META_ATTRIBUTES, attr_set, attr_id,
	attr_name, &xml_search);

	if (rc == pcmk_rc_ok \|\| rc == ENOTUNIQ) {
	char *found_attr_id = NULL;

	found_attr_id = crm_element_value_copy(xml_search, PCMK_XA_ID);

	if (!out->is_quiet(out)) {
	out->err(out,
	"WARNING: There is already a meta attribute "
	"for '%s' called '%s' (id=%s)",
	top_id, attr_name, found_attr_id);
	out->err(out,
	" Delete '%s' first or use the force option "
	"to override", found_attr_id);
	}

	free(found_attr_id);
	pcmk__xml_free(xml_search);
	return ENOTUNIQ;
	}

	pcmk__xml_free(xml_search);
	}

	resources = g_list_append(resources, rsc);

	} else {
	*resources = find_matching_attr_resources(out, rsc, requested_name,
	attr_set, attr_set_type,
	attr_id, attr_name, cib,
	"update", force);
	}

	/* If the user specified attr_set or attr_id, the intent is to modify a
	* single resource, which will be the last item in the list.
	*/
	if ((attr_set != NULL) \|\| (attr_id != NULL)) {
	GList last = g_list_last(resources);

	resources = g_list_remove_link(resources, last);
	g_list_free(*resources);
	*resources = last;
	}

	return pcmk_rc_ok;
	}

	static void
	free_attr_update_data(gpointer data)
	{
	attr_update_data_t *ud = data;

	if (ud == NULL) {
	return;
	}

	free(ud->attr_set_type);
	free(ud->attr_set_id);
	free(ud->attr_name);
	free(ud->attr_value);
	free(ud->given_rsc_id);
	free(ud->found_attr_id);
	free(ud);
	}

	static int
	update_attribute(pcmk_resource_t rsc, const char requested_name,
	const char attr_set, const char attr_set_type,
	const char attr_id, const char attr_name,
	const char attr_value, gboolean recursive, cib_t cib,
	gboolean force, GList **results)
	{
	pcmk__output_t *out = rsc->priv->scheduler->priv->out;
	int rc = pcmk_rc_ok;

	GList/<pcmk_resource_t>/ resources = NULL;
	const char *top_id = pe__const_top_resource(rsc, false)->id;

	if ((attr_id == NULL) && !force) {
	find_resource_attr(out, cib, PCMK_XA_ID, top_id, NULL, NULL, NULL,
	attr_name, NULL);
	}

	rc = resources_with_attr(out, cib, rsc, requested_name, attr_set, attr_set_type,
	attr_id, attr_name, top_id, force, &resources);

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

	for (GList *iter = resources; iter != NULL; iter = iter->next) {
	char *lookup_id = NULL;
	char *local_attr_set = NULL;
	char *found_attr_id = NULL;
	const char *rsc_attr_id = attr_id;
	const char *rsc_attr_set = attr_set;

	xmlNode *xml_top = NULL;
	xmlNode *xml_obj = NULL;
	xmlNode *xml_search = NULL;

	rsc = (pcmk_resource_t *) iter->data;

	lookup_id = clone_strip(rsc->id); /* Could be a cloned group! */
	rc = find_resource_attr(out, cib, PCMK_XA_ID, lookup_id, attr_set_type,
	attr_set, attr_id, attr_name, &xml_search);

	switch (rc) {
	case pcmk_rc_ok:
	found_attr_id = crm_element_value_copy(xml_search, PCMK_XA_ID);
	crm_debug("Found a match for " PCMK_XA_NAME "='%s': "
	PCMK_XA_ID "='%s'", attr_name, found_attr_id);
	rsc_attr_id = found_attr_id;
	break;

	case ENXIO:
	if (rsc_attr_set == NULL) {
	local_attr_set = crm_strdup_printf("%s-%s", lookup_id,
	attr_set_type);
	rsc_attr_set = local_attr_set;
	}
	if (rsc_attr_id == NULL) {
	found_attr_id = crm_strdup_printf("%s-%s",
	rsc_attr_set, attr_name);
	rsc_attr_id = found_attr_id;
	}

	xml_top = pcmk__xe_create(NULL,
	(const char *)
	rsc->priv->xml->name);
	crm_xml_add(xml_top, PCMK_XA_ID, lookup_id);

	xml_obj = pcmk__xe_create(xml_top, attr_set_type);
	crm_xml_add(xml_obj, PCMK_XA_ID, rsc_attr_set);
	break;

	default:
	free(lookup_id);
	free(found_attr_id);
	pcmk__xml_free(xml_search);
	g_list_free(resources);
	return rc;
	}

	xml_obj = crm_create_nvpair_xml(xml_obj, rsc_attr_id, attr_name,
	attr_value);
	if (xml_top == NULL) {
	xml_top = xml_obj;
	}

	crm_log_xml_debug(xml_top, "Update");

	rc = cib->cmds->modify(cib, PCMK_XE_RESOURCES, xml_top, cib_sync_call);
	rc = pcmk_legacy2rc(rc);
	if (rc == pcmk_rc_ok) {
	attr_update_data_t *ud = pcmk__assert_alloc(1, sizeof(attr_update_data_t));

	if (attr_set_type == NULL) {
	attr_set_type = (const char *) xml_search->parent->name;
	}

	if (rsc_attr_set == NULL) {
	rsc_attr_set = crm_element_value(xml_search->parent, PCMK_XA_ID);
	}

	ud->attr_set_type = pcmk__str_copy(attr_set_type);
	ud->attr_set_id = pcmk__str_copy(rsc_attr_set);
	ud->attr_name = pcmk__str_copy(attr_name);
	ud->attr_value = pcmk__str_copy(attr_value);
	ud->given_rsc_id = pcmk__str_copy(lookup_id);
	ud->found_attr_id = pcmk__str_copy(found_attr_id);
	ud->rsc = rsc;

	results = g_list_append(results, ud);
	}

	pcmk__xml_free(xml_top);
	pcmk__xml_free(xml_search);

	free(lookup_id);
	free(found_attr_id);
	free(local_attr_set);

	if (recursive
	&& pcmk__str_eq(attr_set_type, PCMK_XE_META_ATTRIBUTES,
	pcmk__str_casei)) {
	/* We want to set the attribute only on resources explicitly
	* colocated with this one, so we use
	* rsc->priv->with_this_colocations directly rather than the
	* with_this_colocations() method.
	*/
	pcmk__set_rsc_flags(rsc, pcmk__rsc_detect_loop);
	for (GList *lpc = rsc->priv->with_this_colocations;
	lpc != NULL; lpc = lpc->next) {
	pcmk__colocation_t cons = (pcmk__colocation_t ) lpc->data;

	crm_debug("Checking %s %d", cons->id, cons->score);

	if (pcmk_is_set(cons->dependent->flags, pcmk__rsc_detect_loop)
	\|\| (cons->score <= 0)) {
	continue;
	}

	crm_debug("Setting %s=%s for dependent resource %s",
	attr_name, attr_value, cons->dependent->id);
	update_attribute(cons->dependent, cons->dependent->id, NULL,
	attr_set_type, NULL, attr_name, attr_value,
	recursive, cib, force, results);
	}
	}
	}

	g_list_free(resources);
	return rc;
	}

	// \return Standard Pacemaker return code
	int
	cli_resource_update_attribute(pcmk_resource_t rsc, const char requested_name,
	const char attr_set, const char attr_set_type,
	const char attr_id, const char attr_name,
	const char *attr_value, gboolean recursive,
	cib_t *cib, gboolean force)
	{
	static bool need_init = true;
	int rc = pcmk_rc_ok;

	GList *results = NULL;
	pcmk__output_t *out = rsc->priv->scheduler->priv->out;

	/* If we were asked to update the attribute in a resource element (for
	* instance, <primitive class="ocf">) there's really not much we need to do.
	*/
	if (pcmk__str_eq(attr_set_type, ATTR_SET_ELEMENT, pcmk__str_none)) {
	return update_element_attribute(out, rsc, cib, attr_name, attr_value);
	}

	/* One time initialization - clear flags so we can detect loops */
	if (need_init) {
	need_init = false;
	pcmk__unpack_constraints(rsc->priv->scheduler);
	pe__clear_resource_flags_on_all(rsc->priv->scheduler,
	pcmk__rsc_detect_loop);
	}

	rc = update_attribute(rsc, requested_name, attr_set, attr_set_type,
	attr_id, attr_name, attr_value, recursive, cib,
	force, &results);

	if (rc == pcmk_rc_ok) {
	if (results == NULL) {
	return rc;
	}

	out->message(out, "attribute-changed-list", results);
	g_list_free_full(results, free_attr_update_data);
	}

	return rc;
	}

	// \return Standard Pacemaker return code
	int
	cli_resource_delete_attribute(pcmk_resource_t rsc, const char requested_name,
	const char attr_set, const char attr_set_type,
	const char attr_id, const char attr_name,
	cib_t *cib, int cib_options, gboolean force)
	{
	pcmk__output_t *out = rsc->priv->scheduler->priv->out;
	int rc = pcmk_rc_ok;
	GList/<pcmk_resource_t>/ resources = NULL;

	if ((attr_id == NULL) && !force) {
	find_resource_attr(out, cib, PCMK_XA_ID,
	pe__const_top_resource(rsc, false)->id, NULL,
	NULL, NULL, attr_name, NULL);
	}

	if (pcmk__str_eq(attr_set_type, PCMK_XE_META_ATTRIBUTES, pcmk__str_casei)) {
	resources = find_matching_attr_resources(out, rsc, requested_name,
	attr_set, attr_set_type,
	attr_id, attr_name, cib,
	"delete", force);

	} else if (pcmk__str_eq(attr_set_type, ATTR_SET_ELEMENT, pcmk__str_none)) {
	pcmk__xe_remove_attr(rsc->priv->xml, attr_name);
	CRM_ASSERT(cib != NULL);
	rc = cib->cmds->replace(cib, PCMK_XE_RESOURCES, rsc->priv->xml,
	cib_options);
	rc = pcmk_legacy2rc(rc);
	if (rc == pcmk_rc_ok) {
	out->info(out, "Deleted attribute: %s", attr_name);
	}
	return rc;

	} else {
	resources = g_list_append(resources, rsc);
	}

	for (GList *iter = resources; iter != NULL; iter = iter->next) {
	char *lookup_id = NULL;
	xmlNode *xml_obj = NULL;
	xmlNode *xml_search = NULL;
	char *found_attr_id = NULL;
	const char *rsc_attr_id = attr_id;

	rsc = (pcmk_resource_t *) iter->data;

	lookup_id = clone_strip(rsc->id);
	rc = find_resource_attr(out, cib, PCMK_XA_ID, lookup_id, attr_set_type,
	attr_set, attr_id, attr_name, &xml_search);
	switch (rc) {
	case pcmk_rc_ok:
	found_attr_id = crm_element_value_copy(xml_search, PCMK_XA_ID);
	pcmk__xml_free(xml_search);
	break;

	case ENXIO:
	free(lookup_id);
	pcmk__xml_free(xml_search);
	continue;

	default:
	free(lookup_id);
	pcmk__xml_free(xml_search);
	g_list_free(resources);
	return rc;
	}

	if (rsc_attr_id == NULL) {
	rsc_attr_id = found_attr_id;
	}

	xml_obj = crm_create_nvpair_xml(NULL, rsc_attr_id, attr_name, NULL);
	crm_log_xml_debug(xml_obj, "Delete");

	CRM_ASSERT(cib);
	rc = cib->cmds->remove(cib, PCMK_XE_RESOURCES, xml_obj, cib_options);
	rc = pcmk_legacy2rc(rc);

	if (rc == pcmk_rc_ok) {
	out->info(out, "Deleted '%s' option: " PCMK_XA_ID "=%s%s%s%s%s",
	lookup_id, found_attr_id,
	((attr_set == NULL)? "" : " set="),
	pcmk__s(attr_set, ""),
	((attr_name == NULL)? "" : " " PCMK_XA_NAME "="),
	pcmk__s(attr_name, ""));
	}

	free(lookup_id);
	pcmk__xml_free(xml_obj);
	free(found_attr_id);
	}
	g_list_free(resources);
	return rc;
	}

	// \return Standard Pacemaker return code
	static int
	send_lrm_rsc_op(pcmk_ipc_api_t *controld_api, bool do_fail_resource,
	const char host_uname, const char rsc_id,
	pcmk_scheduler_t *scheduler)
	{
	pcmk__output_t *out = scheduler->priv->out;
	const char *router_node = host_uname;
	const char *rsc_api_id = NULL;
	const char *rsc_long_id = NULL;
	const char *rsc_class = NULL;
	const char *rsc_provider = NULL;
	const char *rsc_type = NULL;
	bool cib_only = false;
	pcmk_resource_t *rsc = pe_find_resource(scheduler->priv->resources, rsc_id);

	if (rsc == NULL) {
	out->err(out, "Resource %s not found", rsc_id);
	return ENXIO;

	} else if (!pcmk__is_primitive(rsc)) {
	out->err(out, "We can only process primitive resources, not %s", rsc_id);
	return EINVAL;
	}

	rsc_class = crm_element_value(rsc->priv->xml, PCMK_XA_CLASS);
	rsc_provider = crm_element_value(rsc->priv->xml, PCMK_XA_PROVIDER);
	rsc_type = crm_element_value(rsc->priv->xml, PCMK_XA_TYPE);
	if ((rsc_class == NULL) \|\| (rsc_type == NULL)) {
	out->err(out, "Resource %s does not have a class and type", rsc_id);
	return EINVAL;
	}

	{
	pcmk_node_t *node = pcmk_find_node(scheduler, host_uname);

	if (node == NULL) {
	out->err(out, "Node %s not found", host_uname);
	return pcmk_rc_node_unknown;
	}

	if (!(node->details->online)) {
	if (do_fail_resource) {
	out->err(out, "Node %s is not online", host_uname);
	return ENOTCONN;
	} else {
	cib_only = true;
	}
	}
	if (!cib_only && pcmk__is_pacemaker_remote_node(node)) {
	node = pcmk__current_node(node->priv->remote);
	if (node == NULL) {
	out->err(out, "No cluster connection to Pacemaker Remote node %s detected",
	host_uname);
	return ENOTCONN;
	}
	router_node = node->priv->name;
	}
	}

	if (rsc->priv->history_id != NULL) {
	rsc_api_id = rsc->priv->history_id;
	rsc_long_id = rsc->id;
	} else {
	rsc_api_id = rsc->id;
	}
	if (do_fail_resource) {
	return pcmk_controld_api_fail(controld_api, host_uname, router_node,
	rsc_api_id, rsc_long_id,
	rsc_class, rsc_provider, rsc_type);
	} else {
	return pcmk_controld_api_refresh(controld_api, host_uname, router_node,
	rsc_api_id, rsc_long_id, rsc_class,
	rsc_provider, rsc_type, cib_only);
	}
	}

	/*!
	* \internal
	* \brief Get resource name as used in failure-related node attributes
	*
	* \param[in] rsc Resource to check
	*
	* \return Newly allocated string containing resource's fail name
	* \note The caller is responsible for freeing the result.
	*/
	static inline char *
	rsc_fail_name(const pcmk_resource_t *rsc)
	{
	const char *name = pcmk__s(rsc->priv->history_id, rsc->id);

	if (pcmk_is_set(rsc->flags, pcmk__rsc_unique)) {
	return strdup(name);
	}
	return clone_strip(name);
	}

	// \return Standard Pacemaker return code
	static int
	clear_rsc_history(pcmk_ipc_api_t controld_api, const char host_uname,
	const char rsc_id, pcmk_scheduler_t scheduler)
	{
	int rc = pcmk_rc_ok;

	/* Erase the resource's entire LRM history in the CIB, even if we're only
	* clearing a single operation's fail count. If we erased only entries for a
	* single operation, we might wind up with a wrong idea of the current
	* resource state, and we might not re-probe the resource.
	*/
	rc = send_lrm_rsc_op(controld_api, false, host_uname, rsc_id, scheduler);
	if (rc != pcmk_rc_ok) {
	return rc;
	}

	crm_trace("Processing %d mainloop inputs",
	pcmk_controld_api_replies_expected(controld_api));
	while (g_main_context_iteration(NULL, FALSE)) {
	crm_trace("Processed mainloop input, %d still remaining",
	pcmk_controld_api_replies_expected(controld_api));
	}
	return rc;
	}

	// \return Standard Pacemaker return code
	static int
	clear_rsc_failures(pcmk__output_t out, pcmk_ipc_api_t controld_api,
	const char node_name, const char rsc_id, const char *operation,
	const char interval_spec, pcmk_scheduler_t scheduler)
	{
	int rc = pcmk_rc_ok;
	const char *failed_value = NULL;
	const char *failed_id = NULL;
	char *interval_ms_s = NULL;
	GHashTable *rscs = NULL;
	GHashTableIter iter;

	/* Create a hash table to use as a set of resources to clean. This lets us
	* clean each resource only once (per node) regardless of how many failed
	* operations it has.
	*/
	rscs = pcmk__strkey_table(NULL, NULL);

	// Normalize interval to milliseconds for comparison to history entry
	if (operation) {
	guint interval_ms = 0U;

	pcmk_parse_interval_spec(interval_spec, &interval_ms);
	interval_ms_s = crm_strdup_printf("%u", interval_ms);
	}

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

	failed_id = crm_element_value(xml_op, PCMK__XA_RSC_ID);
	if (failed_id == NULL) {
	// Malformed history entry, should never happen
	continue;
	}

	// No resource specified means all resources match
	if (rsc_id) {
	pcmk_resource_t *fail_rsc = NULL;

	fail_rsc = pe_find_resource_with_flags(scheduler->priv->resources,
	failed_id,
	pcmk_rsc_match_history
	\|pcmk_rsc_match_anon_basename);
	if (!fail_rsc \|\| !pcmk__str_eq(rsc_id, fail_rsc->id, pcmk__str_casei)) {
	continue;
	}
	}

	// Host name should always have been provided by this point
	failed_value = crm_element_value(xml_op, PCMK_XA_UNAME);
	if (!pcmk__str_eq(node_name, failed_value, pcmk__str_casei)) {
	continue;
	}

	// No operation specified means all operations match
	if (operation) {
	failed_value = crm_element_value(xml_op, PCMK_XA_OPERATION);
	if (!pcmk__str_eq(operation, failed_value, pcmk__str_casei)) {
	continue;
	}

	// Interval (if operation was specified) defaults to 0 (not all)
	failed_value = crm_element_value(xml_op, PCMK_META_INTERVAL);
	if (!pcmk__str_eq(interval_ms_s, failed_value, pcmk__str_casei)) {
	continue;
	}
	}

	g_hash_table_add(rscs, (gpointer) failed_id);
	}

	free(interval_ms_s);

	g_hash_table_iter_init(&iter, rscs);
	while (g_hash_table_iter_next(&iter, (gpointer *) &failed_id, NULL)) {
	crm_debug("Erasing failures of %s on %s", failed_id, node_name);
	rc = clear_rsc_history(controld_api, node_name, failed_id, scheduler);
	if (rc != pcmk_rc_ok) {
	return rc;
	}
	}
	g_hash_table_destroy(rscs);
	return rc;
	}

	// \return Standard Pacemaker return code
	static int
	clear_rsc_fail_attrs(const pcmk_resource_t rsc, const char operation,
	const char interval_spec, const pcmk_node_t node)
	{
	int rc = pcmk_rc_ok;
	int attr_options = pcmk__node_attr_none;
	char *rsc_name = rsc_fail_name(rsc);

	if (pcmk__is_pacemaker_remote_node(node)) {
	attr_options \|= pcmk__node_attr_remote;
	}

	rc = pcmk__attrd_api_clear_failures(NULL, node->priv->name, rsc_name,
	operation, interval_spec, NULL,
	attr_options);
	free(rsc_name);
	return rc;
	}

	// \return Standard Pacemaker return code
	int
	cli_resource_delete(pcmk_ipc_api_t controld_api, const char host_uname,
	const pcmk_resource_t rsc, const char operation,
	const char *interval_spec, bool just_failures,
	pcmk_scheduler_t *scheduler, gboolean force)
	{
	pcmk__output_t *out = scheduler->priv->out;
	int rc = pcmk_rc_ok;
	pcmk_node_t *node = NULL;

	if (rsc == NULL) {
	return ENXIO;

	} else if (rsc->priv->children != NULL) {

	for (const GList *lpc = rsc->priv->children;
	lpc != NULL; lpc = lpc->next) {

	const pcmk_resource_t child = (const pcmk_resource_t ) lpc->data;

	rc = cli_resource_delete(controld_api, host_uname, child, operation,
	interval_spec, just_failures, scheduler,
	force);
	if (rc != pcmk_rc_ok) {
	return rc;
	}
	}
	return pcmk_rc_ok;

	} else if (host_uname == NULL) {
	GList *lpc = NULL;
	GList *nodes = g_hash_table_get_values(rsc->priv->probed_nodes);

	if(nodes == NULL && force) {
	nodes = pcmk__copy_node_list(scheduler->nodes, false);

	} else if ((nodes == NULL)
	&& pcmk_is_set(rsc->flags, pcmk__rsc_exclusive_probes)) {
	GHashTableIter iter;
	pcmk_node_t *node = NULL;

	g_hash_table_iter_init(&iter, rsc->priv->allowed_nodes);
	while (g_hash_table_iter_next(&iter, NULL, (void**)&node)) {
	if (node->assign->score >= 0) {
	nodes = g_list_prepend(nodes, node);
	}
	}

	} else if(nodes == NULL) {
	nodes = g_hash_table_get_values(rsc->priv->allowed_nodes);
	}

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

	if (node->details->online) {
	rc = cli_resource_delete(controld_api, node->priv->name, rsc,
	operation, interval_spec, just_failures,
	scheduler, force);
	}
	if (rc != pcmk_rc_ok) {
	g_list_free(nodes);
	return rc;
	}
	}

	g_list_free(nodes);
	return pcmk_rc_ok;
	}

	node = pcmk_find_node(scheduler, host_uname);

	if (node == NULL) {
	out->err(out, "Unable to clean up %s because node %s not found",
	rsc->id, host_uname);
	return ENODEV;
	}

	if (!pcmk_is_set(node->priv->flags, pcmk__node_probes_allowed)) {
	out->err(out, "Unable to clean up %s because resource discovery disabled on %s",
	rsc->id, host_uname);
	return EOPNOTSUPP;
	}

	if (controld_api == NULL) {
	out->err(out, "Dry run: skipping clean-up of %s on %s due to CIB_file",
	rsc->id, host_uname);
	return pcmk_rc_ok;
	}

	rc = clear_rsc_fail_attrs(rsc, operation, interval_spec, node);
	if (rc != pcmk_rc_ok) {
	out->err(out, "Unable to clean up %s failures on %s: %s",
	rsc->id, host_uname, pcmk_rc_str(rc));
	return rc;
	}

	if (just_failures) {
	rc = clear_rsc_failures(out, controld_api, host_uname, rsc->id, operation,
	interval_spec, scheduler);
	} else {
	rc = clear_rsc_history(controld_api, host_uname, rsc->id, scheduler);
	}
	if (rc != pcmk_rc_ok) {
	out->err(out, "Cleaned %s failures on %s, but unable to clean history: %s",
	rsc->id, host_uname, pcmk_rc_str(rc));
	} else {
	out->info(out, "Cleaned up %s on %s", rsc->id, host_uname);
	}
	return rc;
	}

	// \return Standard Pacemaker return code
	int
	cli_cleanup_all(pcmk_ipc_api_t controld_api, const char node_name,
	const char operation, const char interval_spec,
	pcmk_scheduler_t *scheduler)
	{
	pcmk__output_t *out = scheduler->priv->out;
	int rc = pcmk_rc_ok;
	int attr_options = pcmk__node_attr_none;
	const char *display_name = node_name? node_name : "all nodes";

	if (controld_api == NULL) {
	out->info(out, "Dry run: skipping clean-up of %s due to CIB_file",
	display_name);
	return rc;
	}

	if (node_name) {
	pcmk_node_t *node = pcmk_find_node(scheduler, node_name);

	if (node == NULL) {
	out->err(out, "Unknown node: %s", node_name);
	return ENXIO;
	}
	if (pcmk__is_pacemaker_remote_node(node)) {
	attr_options \|= pcmk__node_attr_remote;
	}
	}

	rc = pcmk__attrd_api_clear_failures(NULL, node_name, NULL, operation,
	interval_spec, NULL, attr_options);
	if (rc != pcmk_rc_ok) {
	out->err(out, "Unable to clean up all failures on %s: %s",
	display_name, pcmk_rc_str(rc));
	return rc;
	}

	if (node_name) {
	rc = clear_rsc_failures(out, controld_api, node_name, NULL,
	operation, interval_spec, scheduler);
	if (rc != pcmk_rc_ok) {
	out->err(out, "Cleaned all resource failures on %s, but unable to clean history: %s",
	node_name, pcmk_rc_str(rc));
	return rc;
	}
	} else {
	for (GList *iter = scheduler->nodes; iter; iter = iter->next) {
	pcmk_node_t node = (pcmk_node_t ) iter->data;

	rc = clear_rsc_failures(out, controld_api, node->priv->name,
	NULL, operation, interval_spec, scheduler);
	if (rc != pcmk_rc_ok) {
	out->err(out, "Cleaned all resource failures on all nodes, but unable to clean history: %s",
	pcmk_rc_str(rc));
	return rc;
	}
	}
	}

	out->info(out, "Cleaned up all resources on %s", display_name);
	return rc;
	}

	static void
	check_role(resource_checks_t *checks)
	{
	const char *role_s = g_hash_table_lookup(checks->rsc->priv->meta,
	PCMK_META_TARGET_ROLE);

	if (role_s == NULL) {
	return;
	}
	switch (pcmk_parse_role(role_s)) {
	case pcmk_role_stopped:
	checks->flags \|= rsc_remain_stopped;
	break;

	case pcmk_role_unpromoted:
	if (pcmk_is_set(pe__const_top_resource(checks->rsc, false)->flags,
	pcmk__rsc_promotable)) {
	checks->flags \|= rsc_unpromotable;
	}
	break;

	default:
	break;
	}
	}

	static void
	check_managed(resource_checks_t *checks)
	{
	const char *managed_s = g_hash_table_lookup(checks->rsc->priv->meta,
	PCMK_META_IS_MANAGED);

	if ((managed_s != NULL) && !crm_is_true(managed_s)) {
	checks->flags \|= rsc_unmanaged;
	}
	}

	static void
	check_locked(resource_checks_t *checks)
	{
	const pcmk_node_t *lock_node = checks->rsc->priv->lock_node;

	if (lock_node != NULL) {
	checks->flags \|= rsc_locked;
	checks->lock_node = lock_node->priv->name;
	}
	}

	static bool
	node_is_unhealthy(pcmk_node_t *node)
	{
	switch (pe__health_strategy(node->priv->scheduler)) {
	case pcmk__health_strategy_none:
	break;

	case pcmk__health_strategy_no_red:
	if (pe__node_health(node) < 0) {
	return true;
	}
	break;

	case pcmk__health_strategy_only_green:
	if (pe__node_health(node) <= 0) {
	return true;
	}
	break;

	case pcmk__health_strategy_progressive:
	case pcmk__health_strategy_custom:
	/* @TODO These are finite scores, possibly with rules, and possibly
	* combining with other scores, so attributing these as a cause is
	* nontrivial.
	*/
	break;
	}
	return false;
	}

	static void
	check_node_health(resource_checks_t checks, pcmk_node_t node)
	{
	if (node == NULL) {
	GHashTableIter iter;
	bool allowed = false;
	bool all_nodes_unhealthy = true;

	g_hash_table_iter_init(&iter, checks->rsc->priv->allowed_nodes);
	while (g_hash_table_iter_next(&iter, NULL, (void **) &node)) {
	allowed = true;
	if (!node_is_unhealthy(node)) {
	all_nodes_unhealthy = false;
	break;
	}
	}
	if (allowed && all_nodes_unhealthy) {
	checks->flags \|= rsc_node_health;
	}

	} else if (node_is_unhealthy(node)) {
	checks->flags \|= rsc_node_health;
	}
	}

	int
	cli_resource_check(pcmk__output_t out, pcmk_resource_t rsc, pcmk_node_t *node)
	{
	resource_checks_t checks = { .rsc = rsc };

	check_role(&checks);
	check_managed(&checks);
	check_locked(&checks);
	check_node_health(&checks, node);

	return out->message(out, "resource-check-list", &checks);
	}

	// \return Standard Pacemaker return code
	int
	cli_resource_fail(pcmk_ipc_api_t controld_api, const char host_uname,
	const char rsc_id, pcmk_scheduler_t scheduler)
	{
	crm_notice("Failing %s on %s", rsc_id, host_uname);
	return send_lrm_rsc_op(controld_api, true, host_uname, rsc_id, scheduler);
	}

	static GHashTable *
	generate_resource_params(pcmk_resource_t rsc, pcmk_node_t node,
	pcmk_scheduler_t *scheduler)
	{
	GHashTable *params = NULL;
	GHashTable *meta = NULL;
	GHashTable *combined = NULL;
	GHashTableIter iter;
	char *key = NULL;
	char *value = NULL;

	combined = pcmk__strkey_table(free, free);

	params = pe_rsc_params(rsc, node, scheduler);
	if (params != NULL) {
	g_hash_table_iter_init(&iter, params);
	while (g_hash_table_iter_next(&iter, (gpointer ) & key, (gpointer ) & value)) {
	pcmk__insert_dup(combined, key, value);
	}
	}

	meta = pcmk__strkey_table(free, free);
	get_meta_attributes(meta, rsc, NULL, scheduler);
	if (meta != NULL) {
	g_hash_table_iter_init(&iter, meta);
	while (g_hash_table_iter_next(&iter, (gpointer ) & key, (gpointer ) & value)) {
	char *crm_name = crm_meta_name(key);

	g_hash_table_insert(combined, crm_name, strdup(value));
	}
	g_hash_table_destroy(meta);
	}

	return combined;
	}

	bool resource_is_running_on(pcmk_resource_t rsc, const char host)
	{
	bool found = true;
	GList *hIter = NULL;
	GList *hosts = NULL;

	if (rsc == NULL) {
	return false;
	}

	rsc->priv->fns->location(rsc, &hosts, pcmk__rsc_node_current);
	for (hIter = hosts; host != NULL && hIter != NULL; hIter = hIter->next) {
	pcmk_node_t node = (pcmk_node_t ) hIter->data;

	if (pcmk__strcase_any_of(host, node->priv->name, node->priv->id,
	NULL)) {
	crm_trace("Resource %s is running on %s\n", rsc->id, host);
	goto done;
	}
	}

	if (host != NULL) {
	crm_trace("Resource %s is not running on: %s\n", rsc->id, host);
	found = false;

	} else if(host == NULL && hosts == NULL) {
	crm_trace("Resource %s is not running\n", rsc->id);
	found = false;
	}

	done:
	g_list_free(hosts);
	return found;
	}

	/*!
	* \internal
	* \brief Create a list of all resources active on host from a given list
	*
	* \param[in] host Name of host to check whether resources are active
	* \param[in] rsc_list List of resources to check
	*
	* \return New list of resources from list that are active on host
	*/
	static GList *
	get_active_resources(const char host, GList rsc_list)
	{
	GList *rIter = NULL;
	GList *active = NULL;

	for (rIter = rsc_list; rIter != NULL; rIter = rIter->next) {
	pcmk_resource_t rsc = (pcmk_resource_t ) rIter->data;

	/* Expand groups to their members, because if we're restarting a member
	* other than the first, we can't otherwise tell which resources are
	* stopping and starting.
	*/
	if (pcmk__is_group(rsc)) {
	GList *member_active = NULL;

	member_active = get_active_resources(host, rsc->priv->children);
	active = g_list_concat(active, member_active);
	} else if (resource_is_running_on(rsc, host)) {
	active = g_list_append(active, strdup(rsc->id));
	}
	}
	return active;
	}

	static void dump_list(GList items, const char tag)
	{
	int lpc = 0;
	GList *item = NULL;

	for (item = items; item != NULL; item = item->next) {
	crm_trace("%s[%d]: %s", tag, lpc, (char*)item->data);
	lpc++;
	}
	}

	static void display_list(pcmk__output_t out, GList items, const char *tag)
	{
	GList *item = NULL;

	for (item = items; item != NULL; item = item->next) {
	out->info(out, "%s%s", tag, (const char *)item->data);
	}
	}

	/*!
	* \internal
	* \brief Upgrade XML to latest schema version and use it as scheduler input
	*
	* This also updates the scheduler timestamp to the current time.
	*
	* \param[in,out] scheduler Scheduler data to update
	* \param[in,out] xml XML to use as input
	*
	* \return Standard Pacemaker return code
	* \note On success, caller is responsible for freeing memory allocated for
	* scheduler->priv->now.
	*/
	int
	update_scheduler_input(pcmk_scheduler_t scheduler, xmlNode *xml)
	{
	- int rc = pcmk_update_configured_schema(xml, false);
	+ int rc = pcmk__update_configured_schema(xml, false);

	if (rc == pcmk_rc_ok) {
	scheduler->input = *xml;
	scheduler->priv->now = crm_time_new(NULL);
	}
	return pcmk_rc_ok;
	}

	/*!
	* \internal
	* \brief Update scheduler XML input based on a CIB query
	*
	* \param[in] scheduler Scheduler data to initialize
	* \param[in] cib Connection to the CIB manager
	*
	* \return Standard Pacemaker return code
	* \note On success, caller is responsible for freeing memory allocated for
	* scheduler->input and scheduler->priv->now.
	*/
	static int
	update_scheduler_input_to_cib(pcmk__output_t out, pcmk_scheduler_t scheduler,
	cib_t *cib)
	{
	xmlNode *cib_xml_copy = NULL;
	int rc = pcmk_rc_ok;

	rc = cib->cmds->query(cib, NULL, &cib_xml_copy, cib_sync_call);
	rc = pcmk_legacy2rc(rc);

	if (rc != pcmk_rc_ok) {
	out->err(out, "Could not obtain the current CIB: %s (%d)", pcmk_rc_str(rc), rc);
	return rc;
	}
	rc = update_scheduler_input(scheduler, &cib_xml_copy);
	if (rc != pcmk_rc_ok) {
	out->err(out, "Could not upgrade the current CIB XML");
	pcmk__xml_free(cib_xml_copy);
	return rc;
	}

	return rc;
	}

	// \return Standard Pacemaker return code
	static int
	update_dataset(cib_t cib, pcmk_scheduler_t scheduler, bool simulate)
	{
	char *pid = NULL;
	char *shadow_file = NULL;
	cib_t *shadow_cib = NULL;
	int rc = pcmk_rc_ok;

	pcmk__output_t *out = scheduler->priv->out;

	pe_reset_working_set(scheduler);
	pcmk__set_scheduler_flags(scheduler, pcmk__sched_no_counts);
	rc = update_scheduler_input_to_cib(out, scheduler, cib);
	if (rc != pcmk_rc_ok) {
	return rc;
	}

	if(simulate) {
	bool prev_quiet = false;

	pid = pcmk__getpid_s();
	shadow_cib = cib_shadow_new(pid);
	shadow_file = get_shadow_file(pid);

	if (shadow_cib == NULL) {
	out->err(out, "Could not create shadow cib: '%s'", pid);
	rc = ENXIO;
	goto done;
	}

	rc = pcmk__xml_write_file(scheduler->input, shadow_file, false);
	if (rc != pcmk_rc_ok) {
	out->err(out, "Could not populate shadow cib: %s", pcmk_rc_str(rc));
	goto done;
	}

	rc = shadow_cib->cmds->signon(shadow_cib, crm_system_name, cib_command);
	rc = pcmk_legacy2rc(rc);

	if (rc != pcmk_rc_ok) {
	out->err(out, "Could not connect to shadow cib: %s",
	pcmk_rc_str(rc));
	goto done;
	}

	pcmk__schedule_actions(scheduler->input, pcmk__sched_no_counts,
	scheduler);

	prev_quiet = out->is_quiet(out);
	out->quiet = true;
	pcmk__simulate_transition(scheduler, shadow_cib, NULL);
	out->quiet = prev_quiet;

	rc = update_dataset(shadow_cib, scheduler, false);

	} else {
	cluster_status(scheduler);
	}

	done:
	// Do not free scheduler->input because rsc->priv->xml must remain valid
	cib_delete(shadow_cib);
	free(pid);

	if(shadow_file) {
	unlink(shadow_file);
	free(shadow_file);
	}

	return rc;
	}

	/*!
	* \internal
	* \brief Find the maximum stop timeout of a resource and its children (if any)
	*
	* \param[in,out] rsc Resource to get timeout for
	*
	* \return Maximum stop timeout for \p rsc (in milliseconds)
	*/
	static guint
	max_rsc_stop_timeout(pcmk_resource_t *rsc)
	{
	long long result_ll;
	guint max_delay = 0;
	xmlNode *config = NULL;
	GHashTable *meta = NULL;

	if (rsc == NULL) {
	return 0;
	}

	// If resource is collective, use maximum of its children's stop timeouts
	if (rsc->priv->children != NULL) {

	for (GList *iter = rsc->priv->children;
	iter != NULL; iter = iter->next) {

	pcmk_resource_t *child = iter->data;
	guint delay = max_rsc_stop_timeout(child);

	if (delay > max_delay) {
	pcmk__rsc_trace(rsc,
	"Maximum stop timeout for %s is now %s "
	"due to %s", rsc->id,
	pcmk__readable_interval(delay), child->id);
	max_delay = delay;
	}
	}
	return max_delay;
	}

	// Get resource's stop action configuration from CIB
	config = pcmk__find_action_config(rsc, PCMK_ACTION_STOP, 0, true);

	/* Get configured timeout for stop action (fully evaluated for rules,
	* defaults, etc.).
	*
	* @TODO This currently ignores node (which might matter for rules)
	*/
	meta = pcmk__unpack_action_meta(rsc, NULL, PCMK_ACTION_STOP, 0, config);
	if ((pcmk__scan_ll(g_hash_table_lookup(meta, PCMK_META_TIMEOUT),
	&result_ll, -1LL) == pcmk_rc_ok) && (result_ll >= 0)) {
	max_delay = (guint) QB_MIN(result_ll, UINT_MAX);
	}
	g_hash_table_destroy(meta);

	return max_delay;
	}

	/*!
	* \internal
	* \brief Find a reasonable waiting time for stopping any one resource in a list
	*
	* \param[in,out] scheduler Scheduler data
	* \param[in] resources List of names of resources that will be stopped
	*
	* \return Rough estimate of a reasonable time to wait (in seconds) to stop any
	* one resource in \p resources
	* \note This estimate is very rough, simply the maximum stop timeout of all
	* given resources and their children, plus a small fudge factor. It does
	* not account for children that must be stopped in sequence, action
	* throttling, or any demotions needed. It checks the stop timeout, even
	* if the resources in question are actually being started.
	*/
	static guint
	wait_time_estimate(pcmk_scheduler_t scheduler, const GList resources)
	{
	guint max_delay = 0U;

	// Find maximum stop timeout in milliseconds
	for (const GList *item = resources; item != NULL; item = item->next) {
	pcmk_resource_t *rsc = pe_find_resource(scheduler->priv->resources,
	(const char *) item->data);
	guint delay = max_rsc_stop_timeout(rsc);

	if (delay > max_delay) {
	pcmk__rsc_trace(rsc,
	"Wait time is now %s due to %s",
	pcmk__readable_interval(delay), rsc->id);
	max_delay = delay;
	}
	}

	return (max_delay / 1000U) + 5U;
	}

	#define waiting_for_starts(d, r, h) ((d != NULL) \|\| \
	(!resource_is_running_on((r), (h))))

	/*!
	* \internal
	* \brief Restart a resource (on a particular host if requested).
	*
	* \param[in,out] out Output object
	* \param[in,out] rsc The resource to restart
	* \param[in] node Node to restart resource on (NULL for all)
	* \param[in] move_lifetime If not NULL, how long constraint should
	* remain in effect (as ISO 8601 string)
	* \param[in] timeout_ms Consider failed if actions do not complete
	* in this time (specified in milliseconds,
	* but a two-second granularity is actually
	* used; if 0, it will be calculated based on
	* the resource timeout)
	* \param[in,out] cib Connection to the CIB manager
	* \param[in] cib_options Group of enum cib_call_options flags to
	* use with CIB calls
	* \param[in] promoted_role_only If true, limit to promoted instances
	* \param[in] force If true, apply only to requested instance
	* if part of a collective resource
	*
	* \return Standard Pacemaker return code (exits on certain failures)
	*/
	int
	cli_resource_restart(pcmk__output_t out, pcmk_resource_t rsc,
	const pcmk_node_t node, const char move_lifetime,
	guint timeout_ms, cib_t *cib, int cib_options,
	gboolean promoted_role_only, gboolean force)
	{
	int rc = pcmk_rc_ok;
	int lpc = 0;
	int before = 0;
	guint step_timeout_s = 0;
	guint sleep_interval = 2U;
	guint timeout = timeout_ms / 1000U;

	bool stop_via_ban = false;
	char *rsc_id = NULL;
	char *lookup_id = NULL;
	char *orig_target_role = NULL;

	GList *list_delta = NULL;
	GList *target_active = NULL;
	GList *current_active = NULL;
	GList *restart_target_active = NULL;

	pcmk_scheduler_t *scheduler = NULL;
	pcmk_resource_t *parent = uber_parent(rsc);

	bool running = false;
	const char *id = pcmk__s(rsc->priv->history_id, rsc->id);
	const char *host = node ? node->priv->name : NULL;

	/* If the implicit resource or primitive resource of a bundle is given, operate on the
	* bundle itself instead.
	*/
	if (pcmk__is_bundled(rsc)) {
	rsc = parent->priv->parent;
	}

	running = resource_is_running_on(rsc, host);

	if (pcmk__is_clone(parent) && !running) {
	if (pcmk__is_unique_clone(parent)) {
	lookup_id = strdup(rsc->id);
	} else {
	lookup_id = clone_strip(rsc->id);
	}

	rsc = parent->priv->fns->find_rsc(parent, lookup_id, node,
	pcmk_rsc_match_basename
	\|pcmk_rsc_match_current_node);
	free(lookup_id);
	running = resource_is_running_on(rsc, host);
	}

	if (!running) {
	if (host) {
	out->err(out, "%s is not running on %s and so cannot be restarted", id, host);
	} else {
	out->err(out, "%s is not running anywhere and so cannot be restarted", id);
	}
	return ENXIO;
	}

	if (!pcmk_is_set(rsc->flags, pcmk__rsc_managed)) {
	out->err(out, "Unmanaged resources cannot be restarted.");
	return EAGAIN;
	}

	rsc_id = strdup(rsc->id);

	if (pcmk__is_unique_clone(parent)) {
	lookup_id = strdup(rsc->id);
	} else {
	lookup_id = clone_strip(rsc->id);
	}

	if (host) {
	if (pcmk__is_clone(rsc) \|\| pe_bundle_replicas(rsc)) {
	stop_via_ban = true;
	} else if (pcmk__is_clone(parent)) {
	stop_via_ban = true;
	free(lookup_id);
	lookup_id = strdup(parent->id);
	}
	}

	/*
	grab full cib
	determine originally active resources
	disable or ban
	poll cib and watch for affected resources to get stopped
	without --timeout, calculate the stop timeout for each step and wait for that
	if we hit --timeout or the service timeout, re-enable or un-ban, report failure and indicate which resources we couldn't take down
	if everything stopped, re-enable or un-ban
	poll cib and watch for affected resources to get started
	without --timeout, calculate the start timeout for each step and wait for that
	if we hit --timeout or the service timeout, report (different) failure and indicate which resources we couldn't bring back up
	report success

	Optimizations:
	- use constraints to determine ordered list of affected resources
	- Allow a --no-deps option (aka. --force-restart)
	*/

	scheduler = pe_new_working_set();
	if (scheduler == NULL) {
	rc = errno;
	out->err(out, "Could not allocate scheduler data: %s", pcmk_rc_str(rc));
	goto done;
	}

	scheduler->priv->out = out;
	rc = update_dataset(cib, scheduler, false);

	if(rc != pcmk_rc_ok) {
	out->err(out, "Could not get new resource list: %s (%d)", pcmk_rc_str(rc), rc);
	goto done;
	}

	restart_target_active = get_active_resources(host,
	scheduler->priv->resources);
	current_active = get_active_resources(host, scheduler->priv->resources);

	dump_list(current_active, "Origin");

	if (stop_via_ban) {
	/* Stop the clone or bundle instance by banning it from the host */
	out->quiet = true;
	rc = cli_resource_ban(out, lookup_id, host, move_lifetime, cib,
	cib_options, promoted_role_only,
	PCMK_ROLE_PROMOTED);
	} else {
	xmlNode *xml_search = NULL;

	/* Stop the resource by setting PCMK_META_TARGET_ROLE to Stopped.
	* Remember any existing PCMK_META_TARGET_ROLE so we can restore it
	* later (though it only makes any difference if it's Unpromoted).
	*/

	rc = find_resource_attr(out, cib, PCMK_XA_VALUE, lookup_id, NULL, NULL, NULL,
	PCMK_META_TARGET_ROLE, &xml_search);

	if (rc == pcmk_rc_ok) {
	orig_target_role = crm_element_value_copy(xml_search, PCMK_XA_VALUE);
	}

	pcmk__xml_free(xml_search);

	rc = cli_resource_update_attribute(rsc, rsc_id, NULL,
	PCMK_XE_META_ATTRIBUTES, NULL,
	PCMK_META_TARGET_ROLE,
	PCMK_ACTION_STOPPED, FALSE, cib,
	force);
	}
	if(rc != pcmk_rc_ok) {
	out->err(out, "Could not set " PCMK_META_TARGET_ROLE " for %s: %s (%d)",
	rsc_id, pcmk_rc_str(rc), rc);
	if (current_active != NULL) {
	g_list_free_full(current_active, free);
	current_active = NULL;
	}
	if (restart_target_active != NULL) {
	g_list_free_full(restart_target_active, free);
	restart_target_active = NULL;
	}
	goto done;
	}

	rc = update_dataset(cib, scheduler, true);
	if(rc != pcmk_rc_ok) {
	out->err(out, "Could not determine which resources would be stopped");
	goto failure;
	}

	target_active = get_active_resources(host, scheduler->priv->resources);
	dump_list(target_active, "Target");

	list_delta = pcmk__subtract_lists(current_active, target_active, (GCompareFunc) strcmp);
	out->info(out, "Waiting for %d resources to stop:", g_list_length(list_delta));
	display_list(out, list_delta, " * ");

	step_timeout_s = timeout / sleep_interval;
	while (list_delta != NULL) {
	before = g_list_length(list_delta);
	if(timeout_ms == 0) {
	step_timeout_s = wait_time_estimate(scheduler, list_delta)
	/ sleep_interval;
	}

	/* We probably don't need the entire step timeout */
	for(lpc = 0; (lpc < step_timeout_s) && (list_delta != NULL); lpc++) {
	sleep(sleep_interval);
	if(timeout) {
	timeout -= sleep_interval;
	crm_trace("%us remaining", timeout);
	}
	rc = update_dataset(cib, scheduler, FALSE);
	if(rc != pcmk_rc_ok) {
	out->err(out, "Could not determine which resources were stopped");
	goto failure;
	}

	if (current_active != NULL) {
	g_list_free_full(current_active, free);
	}
	current_active = get_active_resources(host,
	scheduler->priv->resources);

	g_list_free(list_delta);
	list_delta = pcmk__subtract_lists(current_active, target_active, (GCompareFunc) strcmp);

	dump_list(current_active, "Current");
	dump_list(list_delta, "Delta");
	}

	crm_trace("%d (was %d) resources remaining", g_list_length(list_delta), before);
	if(before == g_list_length(list_delta)) {
	/* aborted during stop phase, print the contents of list_delta */
	out->err(out, "Could not complete shutdown of %s, %d resources remaining", rsc_id, g_list_length(list_delta));
	display_list(out, list_delta, " * ");
	rc = ETIME;
	goto failure;
	}

	}

	if (stop_via_ban) {
	rc = cli_resource_clear(lookup_id, host, NULL, cib, cib_options, true, force);

	} else if (orig_target_role) {
	rc = cli_resource_update_attribute(rsc, rsc_id, NULL,
	PCMK_XE_META_ATTRIBUTES, NULL,
	PCMK_META_TARGET_ROLE,
	orig_target_role, FALSE, cib, force);
	free(orig_target_role);
	orig_target_role = NULL;
	} else {
	rc = cli_resource_delete_attribute(rsc, rsc_id, NULL,
	PCMK_XE_META_ATTRIBUTES, NULL,
	PCMK_META_TARGET_ROLE, cib,
	cib_options, force);
	}

	if(rc != pcmk_rc_ok) {
	out->err(out,
	"Could not unset " PCMK_META_TARGET_ROLE " for %s: %s (%d)",
	rsc_id, pcmk_rc_str(rc), rc);
	goto done;
	}

	if (target_active != NULL) {
	g_list_free_full(target_active, free);
	}
	target_active = restart_target_active;

	list_delta = pcmk__subtract_lists(target_active, current_active, (GCompareFunc) strcmp);
	out->info(out, "Waiting for %d resources to start again:", g_list_length(list_delta));
	display_list(out, list_delta, " * ");

	step_timeout_s = timeout / sleep_interval;
	while (waiting_for_starts(list_delta, rsc, host)) {
	before = g_list_length(list_delta);
	if(timeout_ms == 0) {
	step_timeout_s = wait_time_estimate(scheduler, list_delta)
	/ sleep_interval;
	}

	/* We probably don't need the entire step timeout */
	for (lpc = 0; (lpc < step_timeout_s) && waiting_for_starts(list_delta, rsc, host); lpc++) {

	sleep(sleep_interval);
	if(timeout) {
	timeout -= sleep_interval;
	crm_trace("%ds remaining", timeout);
	}

	rc = update_dataset(cib, scheduler, false);
	if(rc != pcmk_rc_ok) {
	out->err(out, "Could not determine which resources were started");
	goto failure;
	}

	/* It's OK if dependent resources moved to a different node,
	* so we check active resources on all nodes.
	*/
	if (current_active != NULL) {
	g_list_free_full(current_active, free);
	}
	current_active = get_active_resources(NULL,
	scheduler->priv->resources);

	g_list_free(list_delta);
	list_delta = pcmk__subtract_lists(target_active, current_active, (GCompareFunc) strcmp);
	dump_list(current_active, "Current");
	dump_list(list_delta, "Delta");
	}

	if(before == g_list_length(list_delta)) {
	/* aborted during start phase, print the contents of list_delta */
	out->err(out, "Could not complete restart of %s, %d resources remaining", rsc_id, g_list_length(list_delta));
	display_list(out, list_delta, " * ");
	rc = ETIME;
	goto failure;
	}

	}

	rc = pcmk_rc_ok;
	goto done;

	failure:
	if (stop_via_ban) {
	cli_resource_clear(lookup_id, host, NULL, cib, cib_options, true, force);
	} else if (orig_target_role) {
	cli_resource_update_attribute(rsc, rsc_id, NULL,
	PCMK_XE_META_ATTRIBUTES, NULL,
	PCMK_META_TARGET_ROLE, orig_target_role,
	FALSE, cib, force);
	free(orig_target_role);
	} else {
	cli_resource_delete_attribute(rsc, rsc_id, NULL,
	PCMK_XE_META_ATTRIBUTES, NULL,
	PCMK_META_TARGET_ROLE, cib, cib_options,
	force);
	}

	done:
	if (list_delta != NULL) {
	g_list_free(list_delta);
	}
	if (current_active != NULL) {
	g_list_free_full(current_active, free);
	}
	if (target_active != NULL && (target_active != restart_target_active)) {
	g_list_free_full(target_active, free);
	}
	if (restart_target_active != NULL) {
	g_list_free_full(restart_target_active, free);
	}
	free(rsc_id);
	free(lookup_id);
	pe_free_working_set(scheduler);
	return rc;
	}

	static inline bool
	action_is_pending(const pcmk_action_t *action)
	{
	if (pcmk_any_flags_set(action->flags,
	pcmk__action_optional\|pcmk__action_pseudo)
	\|\| !pcmk_is_set(action->flags, pcmk__action_runnable)
	\|\| pcmk__str_eq(PCMK_ACTION_NOTIFY, action->task, pcmk__str_casei)) {
	return false;
	}
	return true;
	}

	/*!
	* \internal
	* \brief Check whether any actions in a list are pending
	*
	* \param[in] actions List of actions to check
	*
	* \return true if any actions in the list are pending, otherwise false
	*/
	static bool
	actions_are_pending(const GList *actions)
	{
	for (const GList *action = actions; action != NULL; action = action->next) {
	const pcmk_action_t a = (const pcmk_action_t ) action->data;

	if (action_is_pending(a)) {
	crm_notice("Waiting for %s (flags=%#.8x)", a->uuid, a->flags);
	return true;
	}
	}
	return false;
	}

	static void
	print_pending_actions(pcmk__output_t out, GList actions)
	{
	GList *action;

	out->info(out, "Pending actions:");
	for (action = actions; action != NULL; action = action->next) {
	pcmk_action_t a = (pcmk_action_t ) action->data;

	if (!action_is_pending(a)) {
	continue;
	}

	if (a->node) {
	out->info(out, "\tAction %d: %s\ton %s",
	a->id, a->uuid, pcmk__node_name(a->node));
	} else {
	out->info(out, "\tAction %d: %s", a->id, a->uuid);
	}
	}
	}

	/* For --wait, timeout (in seconds) to use if caller doesn't specify one */
	#define WAIT_DEFAULT_TIMEOUT_S (60 * 60)

	/* For --wait, how long to sleep between cluster state checks */
	#define WAIT_SLEEP_S (2)

	/*!
	* \internal
	* \brief Wait until all pending cluster actions are complete
	*
	* This waits until either the CIB's transition graph is idle or a timeout is
	* reached.
	*
	* \param[in,out] out Output object
	* \param[in] timeout_ms Consider failed if actions do not complete in
	* this time (specified in milliseconds, but
	* one-second granularity is actually used; if 0, a
	* default will be used)
	* \param[in,out] cib Connection to the CIB manager
	*
	* \return Standard Pacemaker return code
	*/
	int
	wait_till_stable(pcmk__output_t out, guint timeout_ms, cib_t cib)
	{
	pcmk_scheduler_t *scheduler = NULL;
	xmlXPathObjectPtr search;
	int rc = pcmk_rc_ok;
	bool pending_unknown_state_resources;
	time_t expire_time = time(NULL);
	time_t time_diff;
	bool printed_version_warning = out->is_quiet(out); // i.e. don't print if quiet
	char *xpath = NULL;

	if (timeout_ms == 0) {
	expire_time += WAIT_DEFAULT_TIMEOUT_S;
	} else {
	expire_time += (timeout_ms + 999) / 1000;
	}

	scheduler = pe_new_working_set();
	if (scheduler == NULL) {
	return ENOMEM;
	}

	xpath = crm_strdup_printf("/" PCMK_XE_CIB "/" PCMK_XE_STATUS
	"/" PCMK__XE_NODE_STATE "/" PCMK__XE_LRM
	"/" PCMK__XE_LRM_RESOURCES
	"/" PCMK__XE_LRM_RESOURCE
	"/" PCMK__XE_LRM_RSC_OP
	"[@" PCMK__XA_RC_CODE "='%d']",
	PCMK_OCF_UNKNOWN);
	do {
	/* Abort if timeout is reached */
	time_diff = expire_time - time(NULL);
	if (time_diff <= 0) {
	print_pending_actions(out, scheduler->priv->actions);
	rc = ETIME;
	break;
	}

	crm_info("Waiting up to %lld seconds for cluster actions to complete",
	(long long) time_diff);

	if (rc == pcmk_rc_ok) { /* this avoids sleep on first loop iteration */
	sleep(WAIT_SLEEP_S);
	}

	/* Get latest transition graph */
	pe_reset_working_set(scheduler);
	rc = update_scheduler_input_to_cib(out, scheduler, cib);
	if (rc != pcmk_rc_ok) {
	break;
	}
	pcmk__schedule_actions(scheduler->input, pcmk__sched_no_counts,
	scheduler);

	if (!printed_version_warning) {
	/* If the DC has a different version than the local node, the two
	* could come to different conclusions about what actions need to be
	* done. Warn the user in this case.
	*
	* @TODO A possible long-term solution would be to reimplement the
	* wait as a new controller operation that would be forwarded to the
	* DC. However, that would have potential problems of its own.
	*/
	const char *dc_version = NULL;

	dc_version = g_hash_table_lookup(scheduler->priv->options,
	PCMK_OPT_DC_VERSION);
	if (!pcmk__str_eq(dc_version, PACEMAKER_VERSION "-" BUILD_VERSION, pcmk__str_casei)) {
	out->info(out, "warning: wait option may not work properly in "
	"mixed-version cluster");
	printed_version_warning = true;
	}
	}

	search = xpath_search(scheduler->input, xpath);
	pending_unknown_state_resources = (numXpathResults(search) > 0);
	freeXpathObject(search);
	} while (actions_are_pending(scheduler->priv->actions)
	\|\| pending_unknown_state_resources);

	pe_free_working_set(scheduler);
	free(xpath);
	return rc;
	}

	static const char *
	get_action(const char *rsc_action) {
	const char *action = NULL;

	if (pcmk__str_eq(rsc_action, "validate", pcmk__str_casei)) {
	action = PCMK_ACTION_VALIDATE_ALL;

	} else if (pcmk__str_eq(rsc_action, "force-check", pcmk__str_casei)) {
	action = PCMK_ACTION_MONITOR;

	} else if (pcmk__strcase_any_of(rsc_action, "force-start", "force-stop",
	"force-demote", "force-promote", NULL)) {
	action = rsc_action+6;
	} else {
	action = rsc_action;
	}

	return action;
	}

	/*!
	* \brief Set up environment variables as expected by resource agents
	*
	* When the cluster executes resource agents, it adds certain environment
	* variables (directly or via resource meta-attributes) expected by some
	* resource agents. Add the essential ones that many resource agents expect, so
	* the behavior is the same for command-line execution.
	*
	* \param[in,out] params Resource parameters that will be passed to agent
	* \param[in] timeout_ms Action timeout (in milliseconds)
	* \param[in] check_level OCF check level
	* \param[in] verbosity Verbosity level
	*/
	static void
	set_agent_environment(GHashTable *params, guint timeout_ms, int check_level,
	int verbosity)
	{
	g_hash_table_insert(params, crm_meta_name(PCMK_META_TIMEOUT),
	crm_strdup_printf("%u", timeout_ms));

	pcmk__insert_dup(params, PCMK_XA_CRM_FEATURE_SET, CRM_FEATURE_SET);

	if (check_level >= 0) {
	char *level = crm_strdup_printf("%d", check_level);

	setenv("OCF_CHECK_LEVEL", level, 1);
	free(level);
	}

	pcmk__set_env_option(PCMK__ENV_DEBUG, ((verbosity > 0)? "1" : "0"), true);
	if (verbosity > 1) {
	setenv("OCF_TRACE_RA", "1", 1);
	}

	/* A resource agent using the standard ocf-shellfuncs library will not print
	* messages to stderr if it doesn't have a controlling terminal (e.g. if
	* crm_resource is called via script or ssh). This forces it to do so.
	*/
	setenv("OCF_TRACE_FILE", "/dev/stderr", 0);
	}

	/*!
	* \internal
	* \brief Apply command-line overrides to resource parameters
	*
	* \param[in,out] params Parameters to be passed to agent
	* \param[in] overrides Parameters to override (or NULL if none)
	*/
	static void
	apply_overrides(GHashTable params, GHashTable overrides)
	{
	if (overrides != NULL) {
	GHashTableIter iter;
	char *name = NULL;
	char *value = NULL;

	g_hash_table_iter_init(&iter, overrides);
	while (g_hash_table_iter_next(&iter, (gpointer *) &name,
	(gpointer *) &value)) {
	pcmk__insert_dup(params, name, value);
	}
	}
	}

	crm_exit_t
	cli_resource_execute_from_params(pcmk__output_t out, const char rsc_name,
	const char rsc_class, const char rsc_prov,
	const char rsc_type, const char rsc_action,
	GHashTable params, GHashTable override_hash,
	guint timeout_ms, int resource_verbose,
	gboolean force, int check_level)
	{
	const char *class = rsc_class;
	const char *action = get_action(rsc_action);
	crm_exit_t exit_code = CRM_EX_OK;
	svc_action_t *op = NULL;

	// If no timeout was provided, use the same default as the cluster
	if (timeout_ms == 0U) {
	timeout_ms = PCMK_DEFAULT_ACTION_TIMEOUT_MS;
	}

	set_agent_environment(params, timeout_ms, check_level, resource_verbose);
	apply_overrides(params, override_hash);

	op = services__create_resource_action(rsc_name? rsc_name : "test",
	rsc_class, rsc_prov, rsc_type, action,
	0, QB_MIN(timeout_ms, INT_MAX),
	params, 0);
	if (op == NULL) {
	out->err(out, "Could not execute %s using %s%s%s:%s: %s",
	action, rsc_class, (rsc_prov? ":" : ""),
	(rsc_prov? rsc_prov : ""), rsc_type, strerror(ENOMEM));
	g_hash_table_destroy(params);
	return CRM_EX_OSERR;
	}

	if (pcmk__str_eq(rsc_class, PCMK_RESOURCE_CLASS_SERVICE, pcmk__str_casei)) {
	class = resources_find_service_class(rsc_type);
	}
	if (!pcmk__strcase_any_of(class, PCMK_RESOURCE_CLASS_OCF,
	PCMK_RESOURCE_CLASS_LSB, NULL)) {
	services__format_result(op, CRM_EX_UNIMPLEMENT_FEATURE, PCMK_EXEC_ERROR,
	"Manual execution of the %s standard is "
	"unsupported", pcmk__s(class, "unspecified"));
	}

	if (op->rc != PCMK_OCF_UNKNOWN) {
	exit_code = op->rc;
	goto done;
	}

	services_action_sync(op);

	// Map results to OCF codes for consistent reporting to user
	{
	enum ocf_exitcode ocf_code = services_result2ocf(class, action, op->rc);

	// Cast variable instead of function return to keep compilers happy
	exit_code = (crm_exit_t) ocf_code;
	}

	done:
	out->message(out, "resource-agent-action", resource_verbose, rsc_class,
	rsc_prov, rsc_type, rsc_name, rsc_action, override_hash,
	exit_code, op->status, services__exit_reason(op),
	op->stdout_data, op->stderr_data);
	services_action_free(op);
	return exit_code;
	}

	/*!
	* \internal
	* \brief Get the timeout the cluster would use for an action
	*
	* \param[in] rsc Resource that action is for
	* \param[in] action Name of action
	*/
	static guint
	get_action_timeout(pcmk_resource_t rsc, const char action)
	{
	long long timeout_ms = -1LL;
	xmlNode *op = pcmk__find_action_config(rsc, action, 0, true);
	GHashTable *meta = pcmk__unpack_action_meta(rsc, NULL, action, 0, op);

	if ((pcmk__scan_ll(g_hash_table_lookup(meta, PCMK_META_TIMEOUT),
	&timeout_ms, -1LL) != pcmk_rc_ok)
	\|\| (timeout_ms <= 0LL)) {
	timeout_ms = PCMK_DEFAULT_ACTION_TIMEOUT_MS;
	}
	g_hash_table_destroy(meta);
	return (guint) QB_MIN(timeout_ms, UINT_MAX);
	}

	crm_exit_t
	cli_resource_execute(pcmk_resource_t rsc, const char requested_name,
	const char rsc_action, GHashTable override_hash,
	guint timeout_ms, cib_t cib, pcmk_scheduler_t scheduler,
	int resource_verbose, gboolean force, int check_level)
	{
	pcmk__output_t *out = scheduler->priv->out;
	crm_exit_t exit_code = CRM_EX_OK;
	const char *rid = requested_name;
	const char *rtype = NULL;
	const char *rprov = NULL;
	const char *rclass = NULL;
	GHashTable *params = NULL;

	if (pcmk__strcase_any_of(rsc_action, "force-start", "force-demote",
	"force-promote", NULL)) {
	if (pcmk__is_clone(rsc)) {
	GList *nodes = cli_resource_search(rsc, requested_name, scheduler);
	if(nodes != NULL && force == FALSE) {
	out->err(out, "It is not safe to %s %s here: the cluster claims it is already active",
	rsc_action, rsc->id);
	out->err(out,
	"Try setting "
	PCMK_META_TARGET_ROLE "=" PCMK_ROLE_STOPPED
	" first or specifying the force option");
	return CRM_EX_UNSAFE;
	}

	g_list_free_full(nodes, free);
	}
	}

	if (pcmk__is_clone(rsc)) {
	/* Grab the first child resource in the hope it's not a group */
	rsc = rsc->priv->children->data;
	}

	if (pcmk__is_group(rsc)) {
	out->err(out, "Sorry, the %s option doesn't support group resources", rsc_action);
	return CRM_EX_UNIMPLEMENT_FEATURE;
	} else if (pcmk__is_bundled(rsc)) {
	out->err(out, "Sorry, the %s option doesn't support bundled resources", rsc_action);
	return CRM_EX_UNIMPLEMENT_FEATURE;
	}

	rclass = crm_element_value(rsc->priv->xml, PCMK_XA_CLASS);
	rprov = crm_element_value(rsc->priv->xml, PCMK_XA_PROVIDER);
	rtype = crm_element_value(rsc->priv->xml, PCMK_XA_TYPE);

	params = generate_resource_params(rsc, NULL /* @TODO use local node */,
	scheduler);

	if (timeout_ms == 0U) {
	timeout_ms = get_action_timeout(rsc, get_action(rsc_action));
	}

	if (!pcmk__is_anonymous_clone(rsc->priv->parent)) {
	rid = rsc->id;
	}

	exit_code = cli_resource_execute_from_params(out, rid, rclass, rprov, rtype, rsc_action,
	params, override_hash, timeout_ms,
	resource_verbose, force, check_level);
	return exit_code;
	}

	// \return Standard Pacemaker return code
	int
	cli_resource_move(const pcmk_resource_t rsc, const char rsc_id,
	const char host_name, const char move_lifetime, cib_t *cib,
	int cib_options, pcmk_scheduler_t *scheduler,
	gboolean promoted_role_only, gboolean force)
	{
	pcmk__output_t *out = scheduler->priv->out;
	int rc = pcmk_rc_ok;
	unsigned int count = 0;
	pcmk_node_t *current = NULL;
	pcmk_node_t *dest = pcmk_find_node(scheduler, host_name);
	bool cur_is_dest = false;

	if (dest == NULL) {
	return pcmk_rc_node_unknown;
	}

	if (promoted_role_only
	&& !pcmk_is_set(rsc->flags, pcmk__rsc_promotable)) {

	const pcmk_resource_t *p = pe__const_top_resource(rsc, false);

	if (pcmk_is_set(p->flags, pcmk__rsc_promotable)) {
	out->info(out, "Using parent '%s' for move instead of '%s'.", rsc->id, rsc_id);
	rsc_id = p->id;
	rsc = p;

	} else {
	out->info(out, "Ignoring --promoted option: %s is not promotable",
	rsc_id);
	promoted_role_only = FALSE;
	}
	}

	current = pe__find_active_requires(rsc, &count);

	if (pcmk_is_set(rsc->flags, pcmk__rsc_promotable)) {
	unsigned int promoted_count = 0;
	pcmk_node_t *promoted_node = NULL;

	for (const GList *iter = rsc->priv->children;
	iter != NULL; iter = iter->next) {

	const pcmk_resource_t child = (const pcmk_resource_t ) iter->data;
	enum rsc_role_e child_role = child->priv->fns->state(child, TRUE);

	if (child_role == pcmk_role_promoted) {
	rsc = child;
	promoted_node = pcmk__current_node(child);
	promoted_count++;
	}
	}
	if (promoted_role_only \|\| (promoted_count != 0)) {
	count = promoted_count;
	current = promoted_node;
	}

	}

	if (count > 1) {
	if (pcmk__is_clone(rsc)) {
	current = NULL;
	} else {
	return pcmk_rc_multiple;
	}
	}

	if (pcmk__same_node(current, dest)) {
	cur_is_dest = true;
	if (force) {
	crm_info("%s is already %s on %s, reinforcing placement with location constraint.",
	rsc_id, promoted_role_only?"promoted":"active",
	pcmk__node_name(dest));
	} else {
	return pcmk_rc_already;
	}
	}

	/* Clear any previous prefer constraints across all nodes. */
	cli_resource_clear(rsc_id, NULL, scheduler->nodes, cib, cib_options, false,
	force);

	/* Clear any previous ban constraints on 'dest'. */
	cli_resource_clear(rsc_id, dest->priv->name, scheduler->nodes, cib,
	cib_options, TRUE, force);

	/* Record an explicit preference for 'dest' */
	rc = cli_resource_prefer(out, rsc_id, dest->priv->name, move_lifetime,
	cib, cib_options, promoted_role_only,
	PCMK_ROLE_PROMOTED);

	crm_trace("%s%s now prefers %s%s",
	rsc->id, (promoted_role_only? " (promoted)" : ""),
	pcmk__node_name(dest), force?"(forced)":"");

	/* only ban the previous location if current location != destination location.
	* it is possible to use -M to enforce a location without regard of where the
	* resource is currently located */
	if (force && !cur_is_dest) {
	/* Ban the original location if possible */
	if(current) {
	(void)cli_resource_ban(out, rsc_id, current->priv->name,
	move_lifetime, cib, cib_options,
	promoted_role_only, PCMK_ROLE_PROMOTED);
	} else if(count > 1) {
	out->info(out, "Resource '%s' is currently %s in %d locations. "
	"One may now move to %s",
	rsc_id, (promoted_role_only? "promoted" : "active"),
	count, pcmk__node_name(dest));
	out->info(out, "To prevent '%s' from being %s at a specific location, "
	"specify a node.",
	rsc_id, (promoted_role_only? "promoted" : "active"));

	} else {
	crm_trace("Not banning %s from its current location: not active", rsc_id);
	}
	}

	return rc;
	}
	diff --git a/tools/crm_simulate.c b/tools/crm_simulate.c
	index 418bc0cbd6..df5359cb4f 100644
	--- a/tools/crm_simulate.c
	+++ b/tools/crm_simulate.c
	@@ -1,585 +1,585 @@
	/*
	* Copyright 2009-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 <stdint.h>
	#include <stdio.h>
	#include <unistd.h>
	#include <stdlib.h>
	#include <time.h>

	#include <sys/stat.h>
	#include <sys/param.h>
	#include <sys/types.h>
	#include <dirent.h>

	#include <crm/crm.h>
	#include <crm/cib.h>
	#include <crm/cib/internal.h>
	#include <crm/common/cmdline_internal.h>
	#include <crm/common/output_internal.h>
	#include <crm/common/output.h>
	#include <crm/common/util.h>
	#include <crm/common/iso8601.h>
	#include <crm/pengine/status.h>
	#include <crm/pengine/internal.h>
	#include <pacemaker-internal.h>
	#include <pacemaker.h>

	#define SUMMARY "crm_simulate - simulate a Pacemaker cluster's response to events"

	struct {
	char *dot_file;
	char *graph_file;
	gchar *input_file;
	pcmk_injections_t *injections;
	unsigned int flags;
	gchar *output_file;
	long long repeat;
	gboolean store;
	gchar *test_dir;
	char *use_date;
	char *xml_file;
	} options = {
	.flags = pcmk_sim_show_pending \| pcmk_sim_sanitized,
	.repeat = 1
	};

	uint32_t section_opts = 0;
	char *temp_shadow = NULL;
	crm_exit_t exit_code = CRM_EX_OK;

	#define INDENT " "

	static pcmk__supported_format_t formats[] = {
	PCMK__SUPPORTED_FORMAT_NONE,
	PCMK__SUPPORTED_FORMAT_TEXT,
	PCMK__SUPPORTED_FORMAT_XML,
	{ NULL, NULL, NULL }
	};

	static gboolean
	all_actions_cb(const gchar option_name, const gchar optarg, gpointer data, GError **error) {
	options.flags \|= pcmk_sim_all_actions;
	return TRUE;
	}

	static gboolean
	attrs_cb(const gchar option_name, const gchar optarg, gpointer data, GError **error) {
	section_opts \|= pcmk_section_attributes;
	return TRUE;
	}

	static gboolean
	failcounts_cb(const gchar option_name, const gchar optarg, gpointer data, GError **error) {
	section_opts \|= pcmk_section_failcounts \| pcmk_section_failures;
	return TRUE;
	}

	static gboolean
	in_place_cb(const gchar option_name, const gchar optarg, gpointer data, GError **error) {
	options.store = TRUE;
	options.flags \|= pcmk_sim_process \| pcmk_sim_simulate;
	return TRUE;
	}

	static gboolean
	live_check_cb(const gchar option_name, const gchar optarg, gpointer data, GError **error) {
	if (options.xml_file) {
	free(options.xml_file);
	}

	options.xml_file = NULL;
	options.flags &= ~pcmk_sim_sanitized;
	return TRUE;
	}

	static gboolean
	node_down_cb(const gchar option_name, const gchar optarg, gpointer data, GError **error) {
	options.injections->node_down = g_list_append(options.injections->node_down, g_strdup(optarg));
	return TRUE;
	}

	static gboolean
	node_fail_cb(const gchar option_name, const gchar optarg, gpointer data, GError **error) {
	options.injections->node_fail = g_list_append(options.injections->node_fail, g_strdup(optarg));
	return TRUE;
	}

	static gboolean
	node_up_cb(const gchar option_name, const gchar optarg, gpointer data, GError **error) {
	pcmk__simulate_node_config = true;
	options.injections->node_up = g_list_append(options.injections->node_up, g_strdup(optarg));
	return TRUE;
	}

	static gboolean
	op_fail_cb(const gchar option_name, const gchar optarg, gpointer data, GError **error) {
	options.flags \|= pcmk_sim_process \| pcmk_sim_simulate;
	options.injections->op_fail = g_list_append(options.injections->op_fail, g_strdup(optarg));
	return TRUE;
	}

	static gboolean
	op_inject_cb(const gchar option_name, const gchar optarg, gpointer data, GError **error) {
	options.injections->op_inject = g_list_append(options.injections->op_inject, g_strdup(optarg));
	return TRUE;
	}

	static gboolean
	pending_cb(const gchar option_name, const gchar optarg, gpointer data, GError **error) {
	options.flags \|= pcmk_sim_show_pending;
	return TRUE;
	}

	static gboolean
	process_cb(const gchar option_name, const gchar optarg, gpointer data, GError **error) {
	options.flags \|= pcmk_sim_process;
	return TRUE;
	}

	static gboolean
	quorum_cb(const gchar option_name, const gchar optarg, gpointer data, GError **error) {
	pcmk__str_update(&options.injections->quorum, optarg);
	return TRUE;
	}

	static gboolean
	save_dotfile_cb(const gchar option_name, const gchar optarg, gpointer data, GError **error) {
	options.flags \|= pcmk_sim_process;
	pcmk__str_update(&options.dot_file, optarg);
	return TRUE;
	}

	static gboolean
	save_graph_cb(const gchar option_name, const gchar optarg, gpointer data, GError **error) {
	options.flags \|= pcmk_sim_process;
	pcmk__str_update(&options.graph_file, optarg);
	return TRUE;
	}

	static gboolean
	show_scores_cb(const gchar option_name, const gchar optarg, gpointer data, GError **error) {
	options.flags \|= pcmk_sim_process \| pcmk_sim_show_scores;
	return TRUE;
	}

	static gboolean
	simulate_cb(const gchar option_name, const gchar optarg, gpointer data, GError **error) {
	options.flags \|= pcmk_sim_process \| pcmk_sim_simulate;
	return TRUE;
	}

	static gboolean
	ticket_activate_cb(const gchar option_name, const gchar optarg, gpointer data, GError **error) {
	options.injections->ticket_activate = g_list_append(options.injections->ticket_activate, g_strdup(optarg));
	return TRUE;
	}

	static gboolean
	ticket_grant_cb(const gchar option_name, const gchar optarg, gpointer data, GError **error) {
	options.injections->ticket_grant = g_list_append(options.injections->ticket_grant, g_strdup(optarg));
	return TRUE;
	}

	static gboolean
	ticket_revoke_cb(const gchar option_name, const gchar optarg, gpointer data, GError **error) {
	options.injections->ticket_revoke = g_list_append(options.injections->ticket_revoke, g_strdup(optarg));
	return TRUE;
	}

	static gboolean
	ticket_standby_cb(const gchar option_name, const gchar optarg, gpointer data, GError **error) {
	options.injections->ticket_standby = g_list_append(options.injections->ticket_standby, g_strdup(optarg));
	return TRUE;
	}

	static gboolean
	utilization_cb(const gchar option_name, const gchar optarg, gpointer data, GError **error) {
	options.flags \|= pcmk_sim_process \| pcmk_sim_show_utilization;
	return TRUE;
	}

	static gboolean
	watchdog_cb(const gchar option_name, const gchar optarg, gpointer data, GError **error) {
	pcmk__str_update(&options.injections->watchdog, optarg);
	return TRUE;
	}

	static gboolean
	xml_file_cb(const gchar option_name, const gchar optarg, gpointer data, GError **error) {
	pcmk__str_update(&options.xml_file, optarg);
	options.flags \|= pcmk_sim_sanitized;
	return TRUE;
	}

	static gboolean
	xml_pipe_cb(const gchar option_name, const gchar optarg, gpointer data, GError **error) {
	pcmk__str_update(&options.xml_file, "-");
	options.flags \|= pcmk_sim_sanitized;
	return TRUE;
	}

	static GOptionEntry operation_entries[] = {
	{ "run", 'R', G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, process_cb,
	"Process the supplied input and show what actions the cluster will take in response",
	NULL },
	{ "simulate", 'S', G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, simulate_cb,
	"Like --run, but also simulate taking those actions and show the resulting new status",
	NULL },
	{ "in-place", 'X', G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, in_place_cb,
	"Like --simulate, but also store the results back to the input file",
	NULL },
	{ "show-attrs", 'A', G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, attrs_cb,
	"Show node attributes",
	NULL },
	{ "show-failcounts", 'c', G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, failcounts_cb,
	"Show resource fail counts",
	NULL },
	{ "show-scores", 's', G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, show_scores_cb,
	"Show allocation scores",
	NULL },
	{ "show-utilization", 'U', G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, utilization_cb,
	"Show utilization information",
	NULL },
	{ "profile", 'P', 0, G_OPTION_ARG_FILENAME, &options.test_dir,
	"Process all the XML files in the named directory to create profiling data",
	"DIR" },
	{ "repeat", 'N', 0, G_OPTION_ARG_INT, &options.repeat,
	"With --profile, repeat each test N times and print timings",
	"N" },
	/* Deprecated */
	{ "pending", 'j', G_OPTION_FLAG_NO_ARG\|G_OPTION_FLAG_HIDDEN, G_OPTION_ARG_CALLBACK, pending_cb,
	"Display pending state if '" PCMK_META_RECORD_PENDING "' is enabled",
	NULL },

	{ NULL }
	};

	static GOptionEntry synthetic_entries[] = {
	{ "node-up", 'u', 0, G_OPTION_ARG_CALLBACK, node_up_cb,
	"Simulate bringing a node online",
	"NODE" },
	{ "node-down", 'd', 0, G_OPTION_ARG_CALLBACK, node_down_cb,
	"Simulate taking a node offline",
	"NODE" },
	{ "node-fail", 'f', 0, G_OPTION_ARG_CALLBACK, node_fail_cb,
	"Simulate a node failing",
	"NODE" },
	{ "op-inject", 'i', 0, G_OPTION_ARG_CALLBACK, op_inject_cb,
	"Generate a failure for the cluster to react to in the simulation.\n"
	INDENT "See `Operation Specification` help for more information.",
	"OPSPEC" },
	{ "op-fail", 'F', 0, G_OPTION_ARG_CALLBACK, op_fail_cb,
	"If the specified task occurs during the simulation, have it fail with return code ${rc}.\n"
	INDENT "The transition will normally stop at the failed action.\n"
	INDENT "Save the result with --save-output and re-run with --xml-file.\n"
	INDENT "See `Operation Specification` help for more information.",
	"OPSPEC" },
	{ "set-datetime", 't', 0, G_OPTION_ARG_STRING, &options.use_date,
	"Set date/time (ISO 8601 format, see https://en.wikipedia.org/wiki/ISO_8601)",
	"DATETIME" },
	{ "quorum", 'q', 0, G_OPTION_ARG_CALLBACK, quorum_cb,
	"Set to '1' (or 'true') to indicate cluster has quorum",
	"QUORUM" },
	{ "watchdog", 'w', 0, G_OPTION_ARG_CALLBACK, watchdog_cb,
	"Set to '1' (or 'true') to indicate cluster has an active watchdog device",
	"DEVICE" },
	{ "ticket-grant", 'g', 0, G_OPTION_ARG_CALLBACK, ticket_grant_cb,
	"Simulate granting a ticket",
	"TICKET" },
	{ "ticket-revoke", 'r', 0, G_OPTION_ARG_CALLBACK, ticket_revoke_cb,
	"Simulate revoking a ticket",
	"TICKET" },
	{ "ticket-standby", 'b', 0, G_OPTION_ARG_CALLBACK, ticket_standby_cb,
	"Simulate making a ticket standby",
	"TICKET" },
	{ "ticket-activate", 'e', 0, G_OPTION_ARG_CALLBACK, ticket_activate_cb,
	"Simulate activating a ticket",
	"TICKET" },

	{ NULL }
	};

	static GOptionEntry artifact_entries[] = {
	{ "save-input", 'I', 0, G_OPTION_ARG_FILENAME, &options.input_file,
	"Save the input configuration to the named file",
	"FILE" },
	{ "save-output", 'O', 0, G_OPTION_ARG_FILENAME, &options.output_file,
	"Save the output configuration to the named file",
	"FILE" },
	{ "save-graph", 'G', 0, G_OPTION_ARG_CALLBACK, save_graph_cb,
	"Save the transition graph (XML format) to the named file",
	"FILE" },
	{ "save-dotfile", 'D', 0, G_OPTION_ARG_CALLBACK, save_dotfile_cb,
	"Save the transition graph (DOT format) to the named file",
	"FILE" },
	{ "all-actions", 'a', G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, all_actions_cb,
	"Display all possible actions in DOT graph (even if not part of transition)",
	NULL },

	{ NULL }
	};

	static GOptionEntry source_entries[] = {
	{ "live-check", 'L', G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, live_check_cb,
	"Connect to CIB manager and use the current CIB contents as input",
	NULL },
	{ "xml-file", 'x', 0, G_OPTION_ARG_CALLBACK, xml_file_cb,
	"Retrieve XML from the named file",
	"FILE" },
	{ "xml-pipe", 'p', G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, xml_pipe_cb,
	"Retrieve XML from stdin",
	NULL },

	{ NULL }
	};

	static int
	setup_input(pcmk__output_t out, const char input, const char *output,
	GError **error)
	{
	int rc = pcmk_rc_ok;
	xmlNode *cib_object = NULL;
	char *local_output = NULL;

	if (input == NULL) {
	/* Use live CIB */
	rc = cib__signon_query(out, NULL, &cib_object);
	if (rc != pcmk_rc_ok) {
	// cib__signon_query() outputs any relevant error
	return rc;
	}

	} else if (pcmk__str_eq(input, "-", pcmk__str_casei)) {
	cib_object = pcmk__xml_read(NULL);

	} else {
	cib_object = pcmk__xml_read(input);
	}

	if (cib_object == NULL) {
	rc = pcmk_rc_bad_input;
	g_set_error(error, PCMK__EXITC_ERROR, pcmk_rc2exitc(rc),
	"Could not read input XML: %s", pcmk_rc_str(rc));
	return rc;
	}

	if (pcmk_find_cib_element(cib_object, PCMK_XE_STATUS) == NULL) {
	pcmk__xe_create(cib_object, PCMK_XE_STATUS);
	}

	- rc = pcmk_update_configured_schema(&cib_object, false);
	+ rc = pcmk__update_configured_schema(&cib_object, false);
	if (rc != pcmk_rc_ok) {
	pcmk__xml_free(cib_object);
	return rc;
	}

	if (!pcmk__validate_xml(cib_object, NULL, NULL, NULL)) {
	pcmk__xml_free(cib_object);
	return pcmk_rc_schema_validation;
	}

	if (output == NULL) {
	char *pid = pcmk__getpid_s();

	local_output = get_shadow_file(pid);
	temp_shadow = strdup(local_output);
	output = local_output;
	free(pid);
	}

	rc = pcmk__xml_write_file(cib_object, output, false);
	if (rc != pcmk_rc_ok) {
	g_set_error(error, PCMK__EXITC_ERROR, CRM_EX_CANTCREAT,
	"Could not create '%s': %s", output, pcmk_rc_str(rc));
	} else {
	setenv("CIB_file", output, 1);
	}

	pcmk__xml_free(cib_object);
	free(local_output);
	return rc;
	}

	static GOptionContext *
	build_arg_context(pcmk__common_args_t args, GOptionGroup *group) {
	GOptionContext *context = NULL;

	GOptionEntry extra_prog_entries[] = {
	{ "quiet", 'Q', 0, G_OPTION_ARG_NONE, &(args->quiet),
	"Display only essential output",
	NULL },

	{ NULL }
	};

	const char *description = "Operation Specification:\n\n"
	"The OPSPEC in any command line option is of the form\n"
	"${resource}_${task}_${interval_in_ms}@${node}=${rc}\n"
	"(memcached_monitor_20000@bart.example.com=7, for example).\n"
	"${rc} is an OCF return code. For more information on these\n"
	"return codes, refer to https://clusterlabs.org/pacemaker/doc/2.1/Pacemaker_Administration/html/agents.html#ocf-return-codes\n\n"
	"Examples:\n\n"
	"Pretend a recurring monitor action found memcached stopped on node\n"
	"fred.example.com and, during recovery, that the memcached stop\n"
	"action failed:\n\n"
	"\tcrm_simulate -LS --op-inject memcached:0_monitor_20000@bart.example.com=7 "
	"--op-fail memcached:0_stop_0@fred.example.com=1 --save-output /tmp/memcached-test.xml\n\n"
	"Now see what the reaction to the stop failed would be:\n\n"
	"\tcrm_simulate -S --xml-file /tmp/memcached-test.xml\n\n";

	context = pcmk__build_arg_context(args, "text (default), xml", group, NULL);
	pcmk__add_main_args(context, extra_prog_entries);
	g_option_context_set_description(context, description);

	pcmk__add_arg_group(context, "operations", "Operations:",
	"Show operations options", operation_entries);
	pcmk__add_arg_group(context, "synthetic", "Synthetic Cluster Events:",
	"Show synthetic cluster event options", synthetic_entries);
	pcmk__add_arg_group(context, "artifact", "Artifact Options:",
	"Show artifact options", artifact_entries);
	pcmk__add_arg_group(context, "source", "Data Source:",
	"Show data source options", source_entries);

	return context;
	}

	int
	main(int argc, char **argv)
	{
	int rc = pcmk_rc_ok;
	pcmk_scheduler_t *scheduler = NULL;
	pcmk__output_t *out = NULL;

	GError *error = NULL;

	GOptionGroup *output_group = NULL;
	pcmk__common_args_t *args = pcmk__new_common_args(SUMMARY);
	gchar **processed_args = pcmk__cmdline_preproc(argv, "bdefgiqrtuwxDFGINOP");
	GOptionContext *context = build_arg_context(args, &output_group);

	options.injections = calloc(1, sizeof(pcmk_injections_t));
	if (options.injections == NULL) {
	rc = ENOMEM;
	goto done;
	}

	/* This must come before g_option_context_parse_strv. */
	options.xml_file = strdup("-");

	pcmk__register_formats(output_group, formats);
	if (!g_option_context_parse_strv(context, &processed_args, &error)) {
	exit_code = CRM_EX_USAGE;
	goto done;
	}

	pcmk__cli_init_logging("crm_simulate", args->verbosity);

	rc = pcmk__output_new(&out, args->output_ty, args->output_dest, argv);
	if (rc != pcmk_rc_ok) {
	fprintf(stderr, "Error creating output format %s: %s\n",
	args->output_ty, pcmk_rc_str(rc));
	exit_code = CRM_EX_ERROR;
	goto done;
	}

	if (pcmk__str_eq(args->output_ty, "text", pcmk__str_null_matches) &&
	!(pcmk_is_set(options.flags, pcmk_sim_show_scores) && args->quiet)) {
	pcmk__output_text_set_fancy(out, true);
	}

	pe__register_messages(out);
	pcmk__register_lib_messages(out);

	out->quiet = args->quiet;

	if (args->version) {
	out->version(out, false);
	goto done;
	}

	if (args->verbosity > 0) {
	options.flags \|= pcmk_sim_verbose;
	}

	scheduler = pe_new_working_set();
	if (scheduler == NULL) {
	rc = ENOMEM;
	g_set_error(&error, PCMK__RC_ERROR, rc,
	"Could not allocate scheduler data");
	goto done;
	}

	if (pcmk_is_set(options.flags, pcmk_sim_show_scores)) {
	pcmk__set_scheduler_flags(scheduler, pcmk__sched_output_scores);
	}
	if (pcmk_is_set(options.flags, pcmk_sim_show_utilization)) {
	pcmk__set_scheduler_flags(scheduler, pcmk__sched_show_utilization);
	}

	if (options.test_dir != NULL) {
	scheduler->priv->out = out;
	pcmk__profile_dir(options.test_dir, options.repeat, scheduler,
	options.use_date);
	rc = pcmk_rc_ok;
	goto done;
	}

	rc = setup_input(out, options.xml_file,
	options.store? options.xml_file : options.output_file,
	&error);
	if (rc != pcmk_rc_ok) {
	goto done;
	}

	rc = pcmk__simulate(scheduler, out, options.injections, options.flags,
	section_opts, options.use_date, options.input_file,
	options.graph_file, options.dot_file);

	done:
	pcmk__output_and_clear_error(&error, NULL);

	/* There sure is a lot to free in options. */
	free(options.dot_file);
	free(options.graph_file);
	g_free(options.input_file);
	g_free(options.output_file);
	g_free(options.test_dir);
	free(options.use_date);
	free(options.xml_file);

	pcmk_free_injections(options.injections);
	pcmk__free_arg_context(context);
	g_strfreev(processed_args);

	if (scheduler != NULL) {
	pe_free_working_set(scheduler);
	}

	fflush(stderr);

	if (temp_shadow) {
	unlink(temp_shadow);
	free(temp_shadow);
	}

	if (rc != pcmk_rc_ok) {
	exit_code = pcmk_rc2exitc(rc);
	}

	if (out != NULL) {
	out->finish(out, exit_code, true, NULL);
	pcmk__output_free(out);
	}

	pcmk__unregister_formats();
	crm_exit(exit_code);
	}
	diff --git a/tools/crm_ticket.c b/tools/crm_ticket.c
	index 192b8315ca..b6644a1779 100644
	--- a/tools/crm_ticket.c
	+++ b/tools/crm_ticket.c
	@@ -1,667 +1,667 @@
	/*
	* Copyright 2012-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 <sys/param.h>

	#include <crm/crm.h>

	#include <stdio.h>
	#include <sys/types.h>
	#include <unistd.h>

	#include <stdlib.h>
	#include <errno.h>
	#include <fcntl.h>
	#include <libgen.h>

	#include <crm/common/xml.h>
	#include <crm/common/ipc.h>
	#include <crm/common/cmdline_internal.h>

	#include <crm/cib.h>
	#include <crm/cib/internal.h>
	#include <crm/pengine/rules.h>
	#include <crm/pengine/status.h>
	#include <crm/pengine/internal.h>

	#include <pacemaker-internal.h>

	GError *error = NULL;

	#define SUMMARY "Perform tasks related to cluster tickets\n\n" \
	"Allows ticket attributes to be queried, modified and deleted."

	struct {
	gchar *attr_default;
	gchar *attr_id;
	char *attr_name;
	char *attr_value;
	gboolean force;
	char *get_attr_name;
	gboolean quiet;
	gchar *set_name;
	char ticket_cmd;
	gchar *ticket_id;
	gchar *xml_file;
	} options = {
	.ticket_cmd = 'S'
	};

	GList *attr_delete;
	GHashTable *attr_set;
	bool modified = false;
	int cib_options = cib_sync_call;
	static pcmk__output_t *out = NULL;

	#define INDENT " "

	static pcmk__supported_format_t formats[] = {
	PCMK__SUPPORTED_FORMAT_NONE,
	PCMK__SUPPORTED_FORMAT_TEXT,
	PCMK__SUPPORTED_FORMAT_XML,
	{ NULL, NULL, NULL }
	};

	static gboolean
	attr_value_cb(const gchar option_name, const gchar optarg, gpointer data, GError **err) {
	pcmk__str_update(&options.attr_value, optarg);

	if (!options.attr_name \|\| !options.attr_value) {
	return TRUE;
	}

	pcmk__insert_dup(attr_set, options.attr_name, options.attr_value);
	pcmk__str_update(&options.attr_name, NULL);
	pcmk__str_update(&options.attr_value, NULL);

	modified = true;

	return TRUE;
	}

	static gboolean
	command_cb(const gchar option_name, const gchar optarg, gpointer data, GError **err) {
	if (pcmk__str_any_of(option_name, "--info", "-l", NULL)) {
	options.ticket_cmd = 'l';
	} else if (pcmk__str_any_of(option_name, "--details", "-L", NULL)) {
	options.ticket_cmd = 'L';
	} else if (pcmk__str_any_of(option_name, "--raw", "-w", NULL)) {
	options.ticket_cmd = 'w';
	} else if (pcmk__str_any_of(option_name, "--query-xml", "-q", NULL)) {
	options.ticket_cmd = 'q';
	} else if (pcmk__str_any_of(option_name, "--constraints", "-c", NULL)) {
	options.ticket_cmd = 'c';
	} else if (pcmk__str_any_of(option_name, "--cleanup", "-C", NULL)) {
	options.ticket_cmd = 'C';
	}

	return TRUE;
	}

	static gboolean
	delete_attr_cb(const gchar option_name, const gchar optarg, gpointer data, GError **err) {
	attr_delete = g_list_append(attr_delete, strdup(optarg));
	modified = true;
	return TRUE;
	}

	static gboolean
	get_attr_cb(const gchar option_name, const gchar optarg, gpointer data, GError **err) {
	pcmk__str_update(&options.get_attr_name, optarg);
	options.ticket_cmd = 'G';
	return TRUE;
	}

	static gboolean
	grant_standby_cb(const gchar option_name, const gchar optarg, gpointer data, GError **err) {
	if (pcmk__str_any_of(option_name, "--grant", "-g", NULL)) {
	pcmk__insert_dup(attr_set, PCMK__XA_GRANTED, PCMK_VALUE_TRUE);
	modified = true;
	} else if (pcmk__str_any_of(option_name, "--revoke", "-r", NULL)) {
	pcmk__insert_dup(attr_set, PCMK__XA_GRANTED, PCMK_VALUE_FALSE);
	modified = true;
	} else if (pcmk__str_any_of(option_name, "--standby", "-s", NULL)) {
	pcmk__insert_dup(attr_set, PCMK_XA_STANDBY, PCMK_VALUE_TRUE);
	modified = true;
	} else if (pcmk__str_any_of(option_name, "--activate", "-a", NULL)) {
	pcmk__insert_dup(attr_set, PCMK_XA_STANDBY, PCMK_VALUE_FALSE);
	modified = true;
	}

	return TRUE;
	}

	static gboolean
	set_attr_cb(const gchar option_name, const gchar optarg, gpointer data, GError **err) {
	pcmk__str_update(&options.attr_name, optarg);

	if (!options.attr_name \|\| !options.attr_value) {
	return TRUE;
	}

	pcmk__insert_dup(attr_set, options.attr_name, options.attr_value);
	pcmk__str_update(&options.attr_name, NULL);
	pcmk__str_update(&options.attr_value, NULL);

	modified = true;

	return TRUE;
	}

	static GOptionEntry query_entries[] = {
	{ "info", 'l', G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, command_cb,
	"Display the information of ticket(s)",
	NULL },

	{ "details", 'L', G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, command_cb,
	"Display the details of ticket(s)",
	NULL },

	{ "raw", 'w', G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, command_cb,
	"Display the IDs of ticket(s)",
	NULL },

	{ "query-xml", 'q', G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, command_cb,
	"Query the XML of ticket(s)",
	NULL },

	{ "constraints", 'c', G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, command_cb,
	"Display the " PCMK_XE_RSC_TICKET " constraints that apply to ticket(s)",
	NULL },

	{ NULL }
	};

	static GOptionEntry command_entries[] = {
	{ "grant", 'g', G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, grant_standby_cb,
	"Grant a ticket to this cluster site",
	NULL },

	{ "revoke", 'r', G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, grant_standby_cb,
	"Revoke a ticket from this cluster site",
	NULL },

	{ "standby", 's', G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, grant_standby_cb,
	"Tell this cluster site this ticket is standby",
	NULL },

	{ "activate", 'a', G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, grant_standby_cb,
	"Tell this cluster site this ticket is active",
	NULL },

	{ NULL }
	};

	static GOptionEntry advanced_entries[] = {
	{ "get-attr", 'G', 0, G_OPTION_ARG_CALLBACK, get_attr_cb,
	"Display the named attribute for a ticket",
	"ATTRIBUTE" },

	{ "set-attr", 'S', 0, G_OPTION_ARG_CALLBACK, set_attr_cb,
	"Set the named attribute for a ticket",
	"ATTRIBUTE" },

	{ "delete-attr", 'D', 0, G_OPTION_ARG_CALLBACK, delete_attr_cb,
	"Delete the named attribute for a ticket",
	"ATTRIBUTE" },

	{ "cleanup", 'C', G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, command_cb,
	"Delete all state of a ticket at this cluster site",
	NULL },

	{ NULL}
	};

	static GOptionEntry addl_entries[] = {
	{ "attr-value", 'v', 0, G_OPTION_ARG_CALLBACK, attr_value_cb,
	"Attribute value to use with -S",
	"VALUE" },

	{ "default", 'd', 0, G_OPTION_ARG_STRING, &options.attr_default,
	"(Advanced) Default attribute value to display if none is found\n"
	INDENT "(for use with -G)",
	"VALUE" },

	{ "force", 'f', 0, G_OPTION_ARG_NONE, &options.force,
	"(Advanced) Force the action to be performed",
	NULL },

	{ "ticket", 't', 0, G_OPTION_ARG_STRING, &options.ticket_id,
	"Ticket ID",
	"ID" },

	{ "xml-file", 'x', G_OPTION_FLAG_HIDDEN, G_OPTION_ARG_STRING, &options.xml_file,
	NULL,
	NULL },

	{ NULL }
	};

	static GOptionEntry deprecated_entries[] = {
	{ "set-name", 'n', 0, G_OPTION_ARG_STRING, &options.set_name,
	"(Advanced) ID of the " PCMK_XE_INSTANCE_ATTRIBUTES " object to change",
	"ID" },

	{ "nvpair", 'i', 0, G_OPTION_ARG_STRING, &options.attr_id,
	"(Advanced) ID of the nvpair object to change/delete",
	"ID" },

	{ "quiet", 'Q', 0, G_OPTION_ARG_NONE, &options.quiet,
	"Print only the value on stdout",
	NULL },

	{ NULL }
	};

	static void
	ticket_grant_warning(gchar *ticket_id)
	{
	out->err(out, "This command cannot help you verify whether '%s' has "
	"been already granted elsewhere.\n"
	"If you really want to grant '%s' to this site now, and "
	"you know what you are doing,\n"
	"please specify --force.",
	ticket_id, ticket_id);
	}

	static void
	ticket_revoke_warning(gchar *ticket_id)
	{
	out->err(out, "Revoking '%s' can trigger the specified '" PCMK_XA_LOSS_POLICY
	"'(s) relating to '%s'.\n\n"
	"You can check that with:\n"
	"crm_ticket --ticket %s --constraints\n\n"
	"Otherwise before revoking '%s', you may want to make '%s'"
	"standby with:\n"
	"crm_ticket --ticket %s --standby\n\n"
	"If you really want to revoke '%s' from this site now, and "
	"you know what you are doing,\n"
	"please specify --force.",
	ticket_id, ticket_id, ticket_id, ticket_id, ticket_id,
	ticket_id, ticket_id);
	}

	static GOptionContext *
	build_arg_context(pcmk__common_args_t args, GOptionGroup *group)
	{
	GOptionContext *context = NULL;

	const char *description = "Examples:\n\n"
	"Display the info of tickets:\n\n"
	"\tcrm_ticket --info\n\n"
	"Display the detailed info of tickets:\n\n"
	"\tcrm_ticket --details\n\n"
	"Display the XML of 'ticketA':\n\n"
	"\tcrm_ticket --ticket ticketA --query-xml\n\n"
	"Display the " PCMK_XE_RSC_TICKET " constraints that apply to 'ticketA':\n\n"
	"\tcrm_ticket --ticket ticketA --constraints\n\n"
	"Grant 'ticketA' to this cluster site:\n\n"
	"\tcrm_ticket --ticket ticketA --grant\n\n"
	"Revoke 'ticketA' from this cluster site:\n\n"
	"\tcrm_ticket --ticket ticketA --revoke\n\n"
	"Make 'ticketA' standby (the cluster site will treat a granted\n"
	"'ticketA' as 'standby', and the dependent resources will be\n"
	"stopped or demoted gracefully without triggering loss-policies):\n\n"
	"\tcrm_ticket --ticket ticketA --standby\n\n"
	"Activate 'ticketA' from being standby:\n\n"
	"\tcrm_ticket --ticket ticketA --activate\n\n"
	"Get the value of the 'granted' attribute for 'ticketA':\n\n"
	"\tcrm_ticket --ticket ticketA --get-attr granted\n\n"
	"Set the value of the 'standby' attribute for 'ticketA':\n\n"
	"\tcrm_ticket --ticket ticketA --set-attr standby --attr-value true\n\n"
	"Delete the 'granted' attribute for 'ticketA':\n\n"
	"\tcrm_ticket --ticket ticketA --delete-attr granted\n\n"
	"Erase the operation history of 'ticketA' at this cluster site,\n"
	"causing the cluster site to 'forget' the existing ticket state:\n\n"
	"\tcrm_ticket --ticket ticketA --cleanup\n\n";

	context = pcmk__build_arg_context(args, "text (default), xml", group, NULL);
	g_option_context_set_description(context, description);

	pcmk__add_arg_group(context, "queries", "Queries:",
	"Show queries", query_entries);
	pcmk__add_arg_group(context, "commands", "Commands:",
	"Show command options", command_entries);
	pcmk__add_arg_group(context, "advanced", "Advanced Options:",
	"Show advanced options", advanced_entries);
	pcmk__add_arg_group(context, "additional", "Additional Options:",
	"Show additional options", addl_entries);
	pcmk__add_arg_group(context, "deprecated", "Deprecated Options:",
	"Show deprecated options", deprecated_entries);

	return context;
	}

	int
	main(int argc, char **argv)
	{
	pcmk_scheduler_t *scheduler = NULL;
	xmlNode *cib_xml_copy = NULL;

	cib_t *cib_conn = NULL;
	crm_exit_t exit_code = CRM_EX_OK;
	int rc = pcmk_rc_ok;

	GOptionGroup *output_group = NULL;
	pcmk__common_args_t *args = NULL;
	GOptionContext *context = NULL;
	gchar **processed_args = NULL;

	attr_set = pcmk__strkey_table(free, free);
	attr_delete = NULL;

	args = pcmk__new_common_args(SUMMARY);
	context = build_arg_context(args, &output_group);
	processed_args = pcmk__cmdline_preproc(argv, "dintvxCDGS");

	pcmk__register_formats(output_group, formats);
	if (!g_option_context_parse_strv(context, &processed_args, &error)) {
	exit_code = CRM_EX_USAGE;
	goto done;
	}

	pcmk__cli_init_logging("crm_ticket", args->verbosity);

	rc = pcmk__output_new(&out, args->output_ty, args->output_dest, argv);
	if (rc != pcmk_rc_ok) {
	exit_code = pcmk_rc2exitc(rc);
	g_set_error(&error, PCMK__EXITC_ERROR, exit_code,
	"Error creating output format %s: %s", args->output_ty,
	pcmk_rc_str(rc));
	goto done;
	}

	pe__register_messages(out);
	pcmk__register_lib_messages(out);

	if (args->version) {
	out->version(out, false);
	goto done;
	}

	scheduler = pe_new_working_set();
	if (scheduler == NULL) {
	rc = errno;
	exit_code = pcmk_rc2exitc(rc);
	g_set_error(&error, PCMK__EXITC_ERROR, exit_code,
	"Could not allocate scheduler data: %s", pcmk_rc_str(rc));
	goto done;
	}
	pcmk__set_scheduler_flags(scheduler, pcmk__sched_no_counts);

	cib_conn = cib_new();
	if (cib_conn == NULL) {
	exit_code = CRM_EX_DISCONNECT;
	g_set_error(&error, PCMK__EXITC_ERROR, exit_code, "Could not connect to the CIB manager");
	goto done;
	}

	rc = cib__signon_attempts(cib_conn, cib_command, 5);
	rc = pcmk_legacy2rc(rc);

	if (rc != pcmk_rc_ok) {
	exit_code = pcmk_rc2exitc(rc);
	g_set_error(&error, PCMK__EXITC_ERROR, exit_code, "Could not connect to the CIB: %s",
	pcmk_rc_str(rc));
	goto done;
	}

	if (options.xml_file != NULL) {
	cib_xml_copy = pcmk__xml_read(options.xml_file);

	} else {
	rc = cib_conn->cmds->query(cib_conn, NULL, &cib_xml_copy,
	cib_sync_call);
	rc = pcmk_legacy2rc(rc);

	if (rc != pcmk_rc_ok) {
	exit_code = pcmk_rc2exitc(rc);
	g_set_error(&error, PCMK__EXITC_ERROR, exit_code, "Could not get local CIB: %s",
	pcmk_rc_str(rc));
	goto done;
	}
	}

	- rc = pcmk_update_configured_schema(&cib_xml_copy, false);
	+ rc = pcmk__update_configured_schema(&cib_xml_copy, false);
	if (rc != pcmk_rc_ok) {
	exit_code = pcmk_rc2exitc(rc);
	g_set_error(&error, PCMK__EXITC_ERROR, exit_code,
	"Could not update local CIB to latest schema version");
	goto done;
	}

	scheduler->input = cib_xml_copy;
	scheduler->priv->now = crm_time_new(NULL);

	cluster_status(scheduler);

	/* For recording the tickets that are referenced in PCMK_XE_RSC_TICKET
	* constraints but have never been granted yet.
	*/
	pcmk__unpack_constraints(scheduler);

	if (options.ticket_cmd == 'l' \|\| options.ticket_cmd == 'L' \|\| options.ticket_cmd == 'w') {
	bool raw = false;
	bool details = false;

	if (options.ticket_cmd == 'L') {
	details = true;
	} else if (options.ticket_cmd == 'w') {
	raw = true;
	}

	rc = pcmk__ticket_info(out, scheduler, options.ticket_id, details, raw);
	exit_code = pcmk_rc2exitc(rc);

	if (rc == ENXIO) {
	g_set_error(&error, PCMK__EXITC_ERROR, exit_code,
	"No such ticket '%s'", options.ticket_id);
	} else if (rc != pcmk_rc_ok) {
	g_set_error(&error, PCMK__EXITC_ERROR, exit_code,
	"Could not get ticket info: %s", pcmk_rc_str(rc));
	}

	} else if (options.ticket_cmd == 'q') {
	rc = pcmk__ticket_state(out, cib_conn, options.ticket_id);

	if (rc != pcmk_rc_ok && rc != pcmk_rc_duplicate_id) {
	exit_code = pcmk_rc2exitc(rc);
	g_set_error(&error, PCMK__EXITC_ERROR, exit_code,
	"Could not query ticket XML: %s", pcmk_rc_str(rc));
	} else {
	exit_code = CRM_EX_OK;
	}

	} else if (options.ticket_cmd == 'c') {
	rc = pcmk__ticket_constraints(out, cib_conn, options.ticket_id);
	exit_code = pcmk_rc2exitc(rc);

	if (rc != pcmk_rc_ok) {
	g_set_error(&error, PCMK__EXITC_ERROR, exit_code,
	"Could not show ticket constraints: %s", pcmk_rc_str(rc));
	}

	} else if (options.ticket_cmd == 'G') {
	if (options.ticket_id == NULL) {
	exit_code = CRM_EX_NOSUCH;
	g_set_error(&error, PCMK__EXITC_ERROR, exit_code,
	"Must supply ticket ID with -t");
	goto done;
	}

	rc = pcmk__ticket_get_attr(out, scheduler, options.ticket_id,
	options.get_attr_name, options.attr_default);
	exit_code = pcmk_rc2exitc(rc);

	} else if (options.ticket_cmd == 'C') {
	if (options.ticket_id == NULL) {
	exit_code = CRM_EX_USAGE;
	g_set_error(&error, PCMK__EXITC_ERROR, exit_code,
	"Must supply ticket ID with -t");
	goto done;
	}

	rc = pcmk__ticket_delete(out, cib_conn, scheduler, options.ticket_id,
	options.force);
	exit_code = pcmk_rc2exitc(rc);

	switch (rc) {
	case ENXIO:
	g_set_error(&error, PCMK__EXITC_ERROR, exit_code,
	"No such ticket '%s'", options.ticket_id);
	break;

	case EACCES:
	ticket_revoke_warning(options.ticket_id);
	break;

	case pcmk_rc_ok:
	case pcmk_rc_duplicate_id:
	break;

	default:
	g_set_error(&error, PCMK__EXITC_ERROR, exit_code,
	"Could not clean up ticket: %s", pcmk_rc_str(rc));
	break;
	}

	} else if (modified) {
	if (options.ticket_id == NULL) {
	exit_code = CRM_EX_USAGE;
	g_set_error(&error, PCMK__EXITC_ERROR, exit_code,
	"Must supply ticket ID with -t");
	goto done;
	}

	if (options.attr_value
	&& (pcmk__str_empty(options.attr_name))) {
	exit_code = CRM_EX_USAGE;
	g_set_error(&error, PCMK__EXITC_ERROR, exit_code,
	"Must supply attribute name with -S for -v %s", options.attr_value);
	goto done;
	}

	if (options.attr_name
	&& (pcmk__str_empty(options.attr_value))) {
	exit_code = CRM_EX_USAGE;
	g_set_error(&error, PCMK__EXITC_ERROR, exit_code,
	"Must supply attribute value with -v for -S %s", options.attr_value);
	goto done;
	}

	if (attr_delete != NULL) {
	rc = pcmk__ticket_remove_attr(out, cib_conn, scheduler, options.ticket_id,
	attr_delete, options.force);

	if (rc == EACCES) {
	ticket_revoke_warning(options.ticket_id);
	exit_code = CRM_EX_UNSAFE;
	g_set_error(&error, PCMK__EXITC_ERROR, exit_code,
	"Ticket modification not allowed without --force");
	goto done;
	}
	} else {
	rc = pcmk__ticket_set_attr(out, cib_conn, scheduler, options.ticket_id,
	attr_set, options.force);

	if (rc == EACCES) {
	const char *value = NULL;

	value = g_hash_table_lookup(attr_set, PCMK__XA_GRANTED);
	if (crm_is_true(value)) {
	ticket_grant_warning(options.ticket_id);
	} else {
	ticket_revoke_warning(options.ticket_id);
	}

	exit_code = CRM_EX_UNSAFE;
	g_set_error(&error, PCMK__EXITC_ERROR, exit_code,
	"Ticket modification not allowed without --force");
	goto done;
	}
	}

	exit_code = pcmk_rc2exitc(rc);

	if (rc != pcmk_rc_ok && error == NULL) {
	g_set_error(&error, PCMK__EXITC_ERROR, exit_code,
	"Could not modify ticket: %s", pcmk_rc_str(rc));
	}

	} else if (options.ticket_cmd == 'S') {
	/* Correct usage was handled in the "if (modified)" block above, so
	* this is just for reporting usage errors
	*/

	if (pcmk__str_empty(options.attr_name)) {
	// We only get here if ticket_cmd was left as default
	exit_code = CRM_EX_USAGE;
	g_set_error(&error, PCMK__EXITC_ERROR, exit_code, "Must supply a command");
	goto done;
	}

	if (options.ticket_id == NULL) {
	exit_code = CRM_EX_USAGE;
	g_set_error(&error, PCMK__EXITC_ERROR, exit_code,
	"Must supply ticket ID with -t");
	goto done;
	}

	if (pcmk__str_empty(options.attr_value)) {
	exit_code = CRM_EX_USAGE;
	g_set_error(&error, PCMK__EXITC_ERROR, exit_code,
	"Must supply value with -v for -S %s", options.attr_name);
	goto done;
	}

	} else {
	exit_code = CRM_EX_USAGE;
	g_set_error(&error, PCMK__EXITC_ERROR, exit_code,
	"Unknown command: %c", options.ticket_cmd);
	}

	done:
	if (attr_set) {
	g_hash_table_destroy(attr_set);
	}
	attr_set = NULL;

	if (attr_delete) {
	g_list_free_full(attr_delete, free);
	}
	attr_delete = NULL;

	pe_free_working_set(scheduler);
	scheduler = NULL;

	cib__clean_up_connection(&cib_conn);

	g_strfreev(processed_args);
	pcmk__free_arg_context(context);
	g_free(options.attr_default);
	g_free(options.attr_id);
	free(options.attr_name);
	free(options.attr_value);
	free(options.get_attr_name);
	g_free(options.set_name);
	g_free(options.ticket_id);
	g_free(options.xml_file);

	pcmk__output_and_clear_error(&error, out);

	if (out != NULL) {
	out->finish(out, exit_code, true, NULL);
	pcmk__output_free(out);
	}

	pcmk__unregister_formats();
	crm_exit(exit_code);
	}

File Metadata

Mime Type: text/x-diff
Expires: Wed, Jun 25, 5:41 AM (21 h, 35 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1952345
Default Alt Text: (290 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions