No OneTemporary
Actions

Size

57 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/daemons/controld/controld_execd_state.c b/daemons/controld/controld_execd_state.c
	index 373b488912..2450a26ba3 100644
	--- a/daemons/controld/controld_execd_state.c
	+++ b/daemons/controld/controld_execd_state.c
	@@ -1,818 +1,818 @@
	/*
	* 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 <errno.h>

	#include <crm/crm.h>
	#include <crm/common/iso8601.h>
	#include <crm/common/xml.h>
	#include <crm/pengine/rules.h>
	#include <crm/pengine/rules_internal.h>
	#include <crm/lrmd_internal.h>

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

	static GHashTable *lrm_state_table = NULL;
	extern GHashTable *proxy_table;
	int lrmd_internal_proxy_send(lrmd_t * lrmd, xmlNode *msg);
	void lrmd_internal_set_proxy_callback(lrmd_t * lrmd, void userdata, void (callback)(lrmd_t lrmd, void userdata, xmlNode *msg));

	static void
	free_rsc_info(gpointer value)
	{
	lrmd_rsc_info_t *rsc_info = value;

	lrmd_free_rsc_info(rsc_info);
	}

	static void
	free_deletion_op(gpointer value)
	{
	struct pending_deletion_op_s *op = value;

	free(op->rsc);
	delete_ha_msg_input(op->input);
	free(op);
	}

	static void
	free_recurring_op(gpointer value)
	{
	active_op_t *op = value;

	free(op->user_data);
	free(op->rsc_id);
	free(op->op_type);
	free(op->op_key);
	if (op->params) {
	g_hash_table_destroy(op->params);
	}
	free(op);
	}

	static gboolean
	fail_pending_op(gpointer key, gpointer value, gpointer user_data)
	{
	lrmd_event_data_t event = { 0, };
	lrm_state_t *lrm_state = user_data;
	active_op_t *op = value;

	crm_trace("Pre-emptively failing " PCMK__OP_FMT " on %s (call=%s, %s)",
	op->rsc_id, op->op_type, op->interval_ms,
	lrm_state->node_name, (char*)key, op->user_data);

	event.type = lrmd_event_exec_complete;
	event.rsc_id = op->rsc_id;
	event.op_type = op->op_type;
	event.user_data = op->user_data;
	event.timeout = 0;
	event.interval_ms = op->interval_ms;
	lrmd__set_result(&event, PCMK_OCF_UNKNOWN_ERROR, PCMK_EXEC_NOT_CONNECTED,
	"Action was pending when executor connection was dropped");
	event.t_run = (unsigned int) op->start_time;
	event.t_rcchange = (unsigned int) op->start_time;

	event.call_id = op->call_id;
	event.remote_nodename = lrm_state->node_name;
	event.params = op->params;

	process_lrm_event(lrm_state, &event, op, NULL);
	lrmd__reset_result(&event);
	return TRUE;
	}

	gboolean
	lrm_state_is_local(lrm_state_t *lrm_state)
	{
	return (lrm_state != NULL)
	&& pcmk__str_eq(lrm_state->node_name, controld_globals.our_nodename,
	pcmk__str_casei);
	}

	/*!
	* \internal
	* \brief Create executor state entry for a node and add it to the state table
	*
	* \param[in] node_name Node to create entry for
	*
	* \return Newly allocated executor state object initialized for \p node_name
	*/
	static lrm_state_t *
	lrm_state_create(const char *node_name)
	{
	lrm_state_t *state = NULL;

	if (!node_name) {
	crm_err("No node name given for lrm state object");
	return NULL;
	}

	state = calloc(1, sizeof(lrm_state_t));
	if (!state) {
	return NULL;
	}

	state->node_name = strdup(node_name);
	state->rsc_info_cache = pcmk__strkey_table(NULL, free_rsc_info);
	state->deletion_ops = pcmk__strkey_table(free, free_deletion_op);
	state->active_ops = pcmk__strkey_table(free, free_recurring_op);
	state->resource_history = pcmk__strkey_table(NULL, history_free);
	state->metadata_cache = metadata_cache_new();

	g_hash_table_insert(lrm_state_table, (char *)state->node_name, state);
	return state;
	}

	static gboolean
	remote_proxy_remove_by_node(gpointer key, gpointer value, gpointer user_data)
	{
	remote_proxy_t *proxy = value;
	const char *node_name = user_data;

	if (pcmk__str_eq(node_name, proxy->node_name, pcmk__str_casei)) {
	return TRUE;
	}

	return FALSE;
	}

	static remote_proxy_t *
	find_connected_proxy_by_node(const char * node_name)
	{
	GHashTableIter gIter;
	remote_proxy_t *proxy = NULL;

	CRM_CHECK(proxy_table != NULL, return NULL);

	g_hash_table_iter_init(&gIter, proxy_table);

	while (g_hash_table_iter_next(&gIter, NULL, (gpointer *) &proxy)) {
	if (proxy->source
	&& pcmk__str_eq(node_name, proxy->node_name, pcmk__str_casei)) {
	return proxy;
	}
	}

	return NULL;
	}

	static void
	remote_proxy_disconnect_by_node(const char * node_name)
	{
	remote_proxy_t *proxy = NULL;

	CRM_CHECK(proxy_table != NULL, return);

	while ((proxy = find_connected_proxy_by_node(node_name)) != NULL) {
	/* mainloop_del_ipc_client() eventually calls remote_proxy_disconnected()
	* , which removes the entry from proxy_table.
	* Do not do this in a g_hash_table_iter_next() loop. */
	if (proxy->source) {
	mainloop_del_ipc_client(proxy->source);
	}
	}

	return;
	}

	static void
	internal_lrm_state_destroy(gpointer data)
	{
	lrm_state_t *lrm_state = data;

	if (!lrm_state) {
	return;
	}

	/* Rather than directly remove the recorded proxy entries from proxy_table,
	* make sure any connected proxies get disconnected. So that
	* remote_proxy_disconnected() will be called and as well remove the
	* entries from proxy_table.
	*/
	remote_proxy_disconnect_by_node(lrm_state->node_name);

	crm_trace("Destroying proxy table %s with %u members",
	lrm_state->node_name, g_hash_table_size(proxy_table));
	// Just in case there's still any leftovers in proxy_table
	g_hash_table_foreach_remove(proxy_table, remote_proxy_remove_by_node, (char *) lrm_state->node_name);
	remote_ra_cleanup(lrm_state);
	lrmd_api_delete(lrm_state->conn);

	if (lrm_state->rsc_info_cache) {
	crm_trace("Destroying rsc info cache with %u members",
	g_hash_table_size(lrm_state->rsc_info_cache));
	g_hash_table_destroy(lrm_state->rsc_info_cache);
	}
	if (lrm_state->resource_history) {
	crm_trace("Destroying history op cache with %u members",
	g_hash_table_size(lrm_state->resource_history));
	g_hash_table_destroy(lrm_state->resource_history);
	}
	if (lrm_state->deletion_ops) {
	crm_trace("Destroying deletion op cache with %u members",
	g_hash_table_size(lrm_state->deletion_ops));
	g_hash_table_destroy(lrm_state->deletion_ops);
	}
	if (lrm_state->active_ops != NULL) {
	crm_trace("Destroying pending op cache with %u members",
	g_hash_table_size(lrm_state->active_ops));
	g_hash_table_destroy(lrm_state->active_ops);
	}
	metadata_cache_free(lrm_state->metadata_cache);

	free((char *)lrm_state->node_name);
	free(lrm_state);
	}

	void
	lrm_state_reset_tables(lrm_state_t * lrm_state, gboolean reset_metadata)
	{
	if (lrm_state->resource_history) {
	crm_trace("Resetting resource history cache with %u members",
	g_hash_table_size(lrm_state->resource_history));
	g_hash_table_remove_all(lrm_state->resource_history);
	}
	if (lrm_state->deletion_ops) {
	crm_trace("Resetting deletion operations cache with %u members",
	g_hash_table_size(lrm_state->deletion_ops));
	g_hash_table_remove_all(lrm_state->deletion_ops);
	}
	if (lrm_state->active_ops != NULL) {
	crm_trace("Resetting active operations cache with %u members",
	g_hash_table_size(lrm_state->active_ops));
	g_hash_table_remove_all(lrm_state->active_ops);
	}
	if (lrm_state->rsc_info_cache) {
	crm_trace("Resetting resource information cache with %u members",
	g_hash_table_size(lrm_state->rsc_info_cache));
	g_hash_table_remove_all(lrm_state->rsc_info_cache);
	}
	if (reset_metadata) {
	metadata_cache_reset(lrm_state->metadata_cache);
	}
	}

	gboolean
	lrm_state_init_local(void)
	{
	if (lrm_state_table) {
	return TRUE;
	}

	lrm_state_table = pcmk__strikey_table(NULL, internal_lrm_state_destroy);
	if (!lrm_state_table) {
	return FALSE;
	}

	proxy_table = pcmk__strikey_table(NULL, remote_proxy_free);
	if (!proxy_table) {
	g_hash_table_destroy(lrm_state_table);
	lrm_state_table = NULL;
	return FALSE;
	}

	return TRUE;
	}

	void
	lrm_state_destroy_all(void)
	{
	if (lrm_state_table) {
	crm_trace("Destroying state table with %u members",
	g_hash_table_size(lrm_state_table));
	g_hash_table_destroy(lrm_state_table); lrm_state_table = NULL;
	}
	if(proxy_table) {
	crm_trace("Destroying proxy table with %u members",
	g_hash_table_size(proxy_table));
	g_hash_table_destroy(proxy_table); proxy_table = NULL;
	}
	}

	lrm_state_t *
	lrm_state_find(const char *node_name)
	{
	if ((node_name == NULL) \|\| (lrm_state_table == NULL)) {
	return NULL;
	}
	return g_hash_table_lookup(lrm_state_table, node_name);
	}

	lrm_state_t *
	lrm_state_find_or_create(const char *node_name)
	{
	lrm_state_t *lrm_state;

	CRM_CHECK(lrm_state_table != NULL, return NULL);

	lrm_state = g_hash_table_lookup(lrm_state_table, node_name);
	if (!lrm_state) {
	lrm_state = lrm_state_create(node_name);
	}

	return lrm_state;
	}

	GList *
	lrm_state_get_list(void)
	{
	if (lrm_state_table == NULL) {
	return NULL;
	}
	return g_hash_table_get_values(lrm_state_table);
	}

	void
	lrm_state_disconnect_only(lrm_state_t * lrm_state)
	{
	int removed = 0;

	if (!lrm_state->conn) {
	return;
	}
	crm_trace("Disconnecting %s", lrm_state->node_name);

	remote_proxy_disconnect_by_node(lrm_state->node_name);

	((lrmd_t *) lrm_state->conn)->cmds->disconnect(lrm_state->conn);

	if (!pcmk_is_set(controld_globals.fsa_input_register, R_SHUTDOWN)) {
	removed = g_hash_table_foreach_remove(lrm_state->active_ops,
	fail_pending_op, lrm_state);
	crm_trace("Synthesized %d operation failures for %s", removed, lrm_state->node_name);
	}
	}

	void
	lrm_state_disconnect(lrm_state_t * lrm_state)
	{
	if (!lrm_state->conn) {
	return;
	}

	lrm_state_disconnect_only(lrm_state);

	lrmd_api_delete(lrm_state->conn);
	lrm_state->conn = NULL;
	}

	int
	lrm_state_is_connected(lrm_state_t * lrm_state)
	{
	if (!lrm_state->conn) {
	return FALSE;
	}
	return ((lrmd_t *) lrm_state->conn)->cmds->is_connected(lrm_state->conn);
	}

	int
	lrm_state_poke_connection(lrm_state_t * lrm_state)
	{

	if (!lrm_state->conn) {
	return -ENOTCONN;
	}
	return ((lrmd_t *) lrm_state->conn)->cmds->poke_connection(lrm_state->conn);
	}

	// \return Standard Pacemaker return code
	int
	controld_connect_local_executor(lrm_state_t *lrm_state)
	{
	int rc = pcmk_rc_ok;

	if (lrm_state->conn == NULL) {
	lrmd_t *api = NULL;

	rc = lrmd__new(&api, NULL, NULL, 0);
	if (rc != pcmk_rc_ok) {
	return rc;
	}
	api->cmds->set_callback(api, lrm_op_callback);
	lrm_state->conn = api;
	}

	rc = ((lrmd_t *) lrm_state->conn)->cmds->connect(lrm_state->conn,
	CRM_SYSTEM_CRMD, NULL);
	rc = pcmk_legacy2rc(rc);

	if (rc == pcmk_rc_ok) {
	lrm_state->num_lrm_register_fails = 0;
	} else {
	lrm_state->num_lrm_register_fails++;
	}
	return rc;
	}

	static remote_proxy_t *
	crmd_remote_proxy_new(lrmd_t lrmd, const char node_name, const char session_id, const char channel)
	{
	struct ipc_client_callbacks proxy_callbacks = {
	.dispatch = remote_proxy_dispatch,
	.destroy = remote_proxy_disconnected
	};
	remote_proxy_t *proxy = remote_proxy_new(lrmd, &proxy_callbacks, node_name,
	session_id, channel);
	return proxy;
	}

	gboolean
	crmd_is_proxy_session(const char *session)
	{
	return g_hash_table_lookup(proxy_table, session) ? TRUE : FALSE;
	}

	void
	crmd_proxy_send(const char session, xmlNode msg)
	{
	remote_proxy_t *proxy = g_hash_table_lookup(proxy_table, session);
	lrm_state_t *lrm_state = NULL;

	if (!proxy) {
	return;
	}
	crm_log_xml_trace(msg, "to-proxy");
	lrm_state = lrm_state_find(proxy->node_name);
	if (lrm_state) {
	crm_trace("Sending event to %.8s on %s", proxy->session_id, proxy->node_name);
	remote_proxy_relay_event(proxy, msg);
	}
	}

	static void
	crmd_proxy_dispatch(const char session, xmlNode msg)
	{
	crm_trace("Processing proxied IPC message from session %s", session);
	crm_log_xml_trace(msg, "controller[inbound]");
	crm_xml_add(msg, PCMK__XA_CRM_SYS_FROM, session);
	if (controld_authorize_ipc_message(msg, NULL, session)) {
	route_message(C_IPC_MESSAGE, msg);
	}
	controld_trigger_fsa();
	}

	static void
	remote_config_check(xmlNode * msg, int call_id, int rc, xmlNode * output, void *user_data)
	{
	if (rc != pcmk_ok) {
	crm_err("Query resulted in an error: %s", pcmk_strerror(rc));

	if (rc == -EACCES \|\| rc == -pcmk_err_schema_validation) {
	crm_err("The cluster is mis-configured - shutting down and staying down");
	}

	} else {
	lrmd_t * lrmd = (lrmd_t *)user_data;
	crm_time_t *now = crm_time_new(NULL);
	GHashTable *config_hash = pcmk__strkey_table(free, free);

	crm_debug("Call %d : Parsing CIB options", call_id);

	pe_unpack_nvpairs(output, output, PCMK_XE_CLUSTER_PROPERTY_SET, NULL,
	config_hash, PCMK_VALUE_CIB_BOOTSTRAP_OPTIONS, FALSE,
	now, NULL);

	/* Now send it to the remote peer */
	lrmd__validate_remote_settings(lrmd, config_hash);

	g_hash_table_destroy(config_hash);
	crm_time_free(now);
	}
	}

	static void
	crmd_remote_proxy_cb(lrmd_t lrmd, void userdata, xmlNode *msg)
	{
	lrm_state_t *lrm_state = userdata;
	const char *session = crm_element_value(msg, F_LRMD_IPC_SESSION);
	remote_proxy_t *proxy = g_hash_table_lookup(proxy_table, session);

	const char *op = crm_element_value(msg, PCMK__XA_LRMD_IPC_OP);
	if (pcmk__str_eq(op, LRMD_IPC_OP_NEW, pcmk__str_casei)) {
	- const char *channel = crm_element_value(msg, F_LRMD_IPC_IPC_SERVER);
	+ const char *channel = crm_element_value(msg, PCMK__XA_LRMD_IPC_SERVER);

	proxy = crmd_remote_proxy_new(lrmd, lrm_state->node_name, session, channel);
	if (!remote_ra_controlling_guest(lrm_state)) {
	if (proxy != NULL) {
	cib_t *cib_conn = controld_globals.cib_conn;

	/* Look up PCMK_OPT_STONITH_WATCHDOG_TIMEOUT and send to the
	* remote peer for validation
	*/
	int rc = cib_conn->cmds->query(cib_conn, PCMK_XE_CRM_CONFIG,
	NULL, cib_scope_local);
	cib_conn->cmds->register_callback_full(cib_conn, rc, 10, FALSE,
	lrmd,
	"remote_config_check",
	remote_config_check,
	NULL);
	}
	} else {
	crm_debug("Skipping remote_config_check for guest-nodes");
	}

	} else if (pcmk__str_eq(op, LRMD_IPC_OP_SHUTDOWN_REQ, pcmk__str_casei)) {
	char *now_s = NULL;

	crm_notice("%s requested shutdown of its remote connection",
	lrm_state->node_name);

	if (!remote_ra_is_in_maintenance(lrm_state)) {
	now_s = pcmk__ttoa(time(NULL));
	update_attrd(lrm_state->node_name, PCMK__NODE_ATTR_SHUTDOWN, now_s,
	NULL, TRUE);
	free(now_s);

	remote_proxy_ack_shutdown(lrmd);

	crm_warn("Reconnection attempts to %s may result in failures that must be cleared",
	lrm_state->node_name);
	} else {
	remote_proxy_nack_shutdown(lrmd);

	crm_notice("Remote resource for %s is not managed so no ordered shutdown happening",
	lrm_state->node_name);
	}
	return;

	} else if (pcmk__str_eq(op, LRMD_IPC_OP_REQUEST, pcmk__str_casei) && proxy && proxy->is_local) {
	/* This is for the controller, which we are, so don't try
	* to send to ourselves over IPC -- do it directly.
	*/
	int flags = 0;
	xmlNode *request = get_message_xml(msg, F_LRMD_IPC_MSG);

	CRM_CHECK(request != NULL, return);
	CRM_CHECK(lrm_state->node_name, return);
	crm_xml_add(request, PCMK_XE_ACL_ROLE, "pacemaker-remote");
	pcmk__update_acl_user(request, F_LRMD_IPC_USER, lrm_state->node_name);

	/* Pacemaker Remote nodes don't know their own names (as known to the
	* cluster). When getting a node info request with no name or ID, add
	* the name, so we don't return info for ourselves instead of the
	* Pacemaker Remote node.
	*/
	if (pcmk__str_eq(crm_element_value(request, PCMK__XA_CRM_TASK),
	CRM_OP_NODE_INFO, pcmk__str_none)) {
	int node_id = 0;

	crm_element_value_int(request, PCMK_XA_ID, &node_id);
	if ((node_id <= 0)
	&& (crm_element_value(request, PCMK_XA_UNAME) == NULL)) {
	crm_xml_add(request, PCMK_XA_UNAME, lrm_state->node_name);
	}
	}

	crmd_proxy_dispatch(session, request);

	crm_element_value_int(msg, F_LRMD_IPC_MSG_FLAGS, &flags);
	if (flags & crm_ipc_client_response) {
	int msg_id = 0;
	xmlNode *op_reply = create_xml_node(NULL, PCMK__XE_ACK);

	crm_xml_add(op_reply, PCMK_XA_FUNCTION, __func__);
	crm_xml_add_int(op_reply, PCMK__XA_LINE, __LINE__);

	crm_element_value_int(msg, F_LRMD_IPC_MSG_ID, &msg_id);
	remote_proxy_relay_response(proxy, op_reply, msg_id);

	free_xml(op_reply);
	}

	} else {
	remote_proxy_cb(lrmd, lrm_state->node_name, msg);
	}
	}


	// \return Standard Pacemaker return code
	int
	controld_connect_remote_executor(lrm_state_t lrm_state, const char server,
	int port, int timeout_ms)
	{
	int rc = pcmk_rc_ok;

	if (lrm_state->conn == NULL) {
	lrmd_t *api = NULL;

	rc = lrmd__new(&api, lrm_state->node_name, server, port);
	if (rc != pcmk_rc_ok) {
	crm_warn("Pacemaker Remote connection to %s:%s failed: %s "
	CRM_XS " rc=%d", server, port, pcmk_rc_str(rc), rc);

	return rc;
	}
	lrm_state->conn = api;
	api->cmds->set_callback(api, remote_lrm_op_callback);
	lrmd_internal_set_proxy_callback(api, lrm_state, crmd_remote_proxy_cb);
	}

	crm_trace("Initiating remote connection to %s:%d with timeout %dms",
	server, port, timeout_ms);
	rc = ((lrmd_t *) lrm_state->conn)->cmds->connect_async(lrm_state->conn,
	lrm_state->node_name,
	timeout_ms);
	if (rc == pcmk_ok) {
	lrm_state->num_lrm_register_fails = 0;
	} else {
	lrm_state->num_lrm_register_fails++; // Ignored for remote connections
	}
	return pcmk_legacy2rc(rc);
	}

	int
	lrm_state_get_metadata(lrm_state_t * lrm_state,
	const char *class,
	const char *provider,
	const char agent, char *output, enum lrmd_call_options options)
	{
	lrmd_key_value_t *params = NULL;

	if (!lrm_state->conn) {
	return -ENOTCONN;
	}

	/* Add the node name to the environment, as is done with normal resource
	* action calls. Meta-data calls shouldn't need it, but some agents are
	* written with an ocf_local_nodename call at the beginning regardless of
	* action. Without the environment variable, the agent would try to contact
	* the controller to get the node name -- but the controller would be
	* blocking on the synchronous meta-data call.
	*
	* At this point, we have to assume that agents are unlikely to make other
	* calls that require the controller, such as crm_node --quorum or
	* --cluster-id.
	*
	* @TODO Make meta-data calls asynchronous. (This will be part of a larger
	* project to make meta-data calls via the executor rather than directly.)
	*/
	params = lrmd_key_value_add(params, CRM_META "_" PCMK__META_ON_NODE,
	lrm_state->node_name);

	return ((lrmd_t *) lrm_state->conn)->cmds->get_metadata_params(lrm_state->conn,
	class, provider, agent, output, options, params);
	}

	int
	lrm_state_cancel(lrm_state_t lrm_state, const char rsc_id, const char *action,
	guint interval_ms)
	{
	if (!lrm_state->conn) {
	return -ENOTCONN;
	}

	/* Figure out a way to make this async?
	* NOTICE: Currently it's synced and directly acknowledged in do_lrm_invoke(). */
	if (is_remote_lrmd_ra(NULL, NULL, rsc_id)) {
	return remote_ra_cancel(lrm_state, rsc_id, action, interval_ms);
	}
	return ((lrmd_t *) lrm_state->conn)->cmds->cancel(lrm_state->conn, rsc_id,
	action, interval_ms);
	}

	lrmd_rsc_info_t *
	lrm_state_get_rsc_info(lrm_state_t * lrm_state, const char *rsc_id, enum lrmd_call_options options)
	{
	lrmd_rsc_info_t *rsc = NULL;

	if (!lrm_state->conn) {
	return NULL;
	}
	if (is_remote_lrmd_ra(NULL, NULL, rsc_id)) {
	return remote_ra_get_rsc_info(lrm_state, rsc_id);
	}

	rsc = g_hash_table_lookup(lrm_state->rsc_info_cache, rsc_id);
	if (rsc == NULL) {
	/* only contact the lrmd if we don't already have a cached rsc info */
	rsc = ((lrmd_t *) lrm_state->conn)->cmds->get_rsc_info(lrm_state->conn, rsc_id, options);
	if (rsc == NULL) {
	return NULL;
	}
	/* cache the result */
	g_hash_table_insert(lrm_state->rsc_info_cache, rsc->id, rsc);
	}

	return lrmd_copy_rsc_info(rsc);

	}

	/*!
	* \internal
	* \brief Initiate a resource agent action
	*
	* \param[in,out] lrm_state Executor state object
	* \param[in] rsc_id ID of resource for action
	* \param[in] action Action to execute
	* \param[in] userdata String to copy and pass to execution callback
	* \param[in] interval_ms Action interval (in milliseconds)
	* \param[in] timeout_ms Action timeout (in milliseconds)
	* \param[in] start_delay_ms Delay (in ms) before initiating action
	* \param[in] parameters Hash table of resource parameters
	* \param[out] call_id Where to store call ID on success
	*
	* \return Standard Pacemaker return code
	*/
	int
	controld_execute_resource_agent(lrm_state_t lrm_state, const char rsc_id,
	const char action, const char userdata,
	guint interval_ms, int timeout_ms,
	int start_delay_ms, GHashTable *parameters,
	int *call_id)
	{
	int rc = pcmk_rc_ok;
	lrmd_key_value_t *params = NULL;

	if (lrm_state->conn == NULL) {
	return ENOTCONN;
	}

	// Convert parameters from hash table to list
	if (parameters != NULL) {
	const char *key = NULL;
	const char *value = NULL;
	GHashTableIter iter;

	g_hash_table_iter_init(&iter, parameters);
	while (g_hash_table_iter_next(&iter, (gpointer *) &key,
	(gpointer *) &value)) {
	params = lrmd_key_value_add(params, key, value);
	}
	}

	if (is_remote_lrmd_ra(NULL, NULL, rsc_id)) {
	rc = controld_execute_remote_agent(lrm_state, rsc_id, action,
	userdata, interval_ms, timeout_ms,
	start_delay_ms, params, call_id);

	} else {
	rc = ((lrmd_t *) lrm_state->conn)->cmds->exec(lrm_state->conn, rsc_id,
	action, userdata,
	interval_ms, timeout_ms,
	start_delay_ms,
	lrmd_opt_notify_changes_only,
	params);
	if (rc < 0) {
	rc = pcmk_legacy2rc(rc);
	} else {
	*call_id = rc;
	rc = pcmk_rc_ok;
	}
	}
	return rc;
	}

	int
	lrm_state_register_rsc(lrm_state_t * lrm_state,
	const char *rsc_id,
	const char *class,
	const char provider, const char agent, enum lrmd_call_options options)
	{
	lrmd_t conn = (lrmd_t ) lrm_state->conn;

	if (conn == NULL) {
	return -ENOTCONN;
	}

	if (is_remote_lrmd_ra(agent, provider, NULL)) {
	return lrm_state_find_or_create(rsc_id)? pcmk_ok : -EINVAL;
	}

	/* @TODO Implement an asynchronous version of this (currently a blocking
	* call to the lrmd).
	*/
	return conn->cmds->register_rsc(lrm_state->conn, rsc_id, class, provider,
	agent, options);
	}

	int
	lrm_state_unregister_rsc(lrm_state_t * lrm_state,
	const char *rsc_id, enum lrmd_call_options options)
	{
	if (!lrm_state->conn) {
	return -ENOTCONN;
	}

	if (is_remote_lrmd_ra(NULL, NULL, rsc_id)) {
	g_hash_table_remove(lrm_state_table, rsc_id);
	return pcmk_ok;
	}

	g_hash_table_remove(lrm_state->rsc_info_cache, rsc_id);

	/* @TODO Optimize this ... this function is a blocking round trip from
	* client to daemon. The controld_execd_state.c code path that uses this
	* function should always treat it as an async operation. The executor API
	* should make an async version available.
	*/
	return ((lrmd_t *) lrm_state->conn)->cmds->unregister_rsc(lrm_state->conn, rsc_id, options);
	}
	diff --git a/daemons/execd/remoted_proxy.c b/daemons/execd/remoted_proxy.c
	index 051acbfd21..426a1739a8 100644
	--- a/daemons/execd/remoted_proxy.c
	+++ b/daemons/execd/remoted_proxy.c
	@@ -1,470 +1,470 @@
	/*
	* 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 "pacemaker-execd.h"
	#include <crm/crm.h>
	#include <crm/common/xml.h>
	#include <crm/services.h>
	#include <crm/common/mainloop.h>
	#include <crm/common/ipc.h>
	#include <crm/common/ipc_internal.h>
	#include <crm/cib/internal.h>
	#include <crm/fencing/internal.h>

	static qb_ipcs_service_t *cib_ro = NULL;
	static qb_ipcs_service_t *cib_rw = NULL;
	static qb_ipcs_service_t *cib_shm = NULL;

	static qb_ipcs_service_t *attrd_ipcs = NULL;
	static qb_ipcs_service_t *crmd_ipcs = NULL;
	static qb_ipcs_service_t *stonith_ipcs = NULL;
	static qb_ipcs_service_t *pacemakerd_ipcs = NULL;

	// An IPC provider is a cluster node controller connecting as a client
	static GList *ipc_providers = NULL;
	/* ipc clients == things like cibadmin, crm_resource, connecting locally */
	static GHashTable *ipc_clients = NULL;

	/*!
	* \internal
	* \brief Get an IPC proxy provider
	*
	* \return Pointer to a provider if one exists, NULL otherwise
	*
	* \note Grab the first provider, which is the most recent connection. That way,
	* if we haven't yet timed out an old, failed connection, we don't try to
	* use it.
	*/
	pcmk__client_t *
	ipc_proxy_get_provider(void)
	{
	return ipc_providers? (pcmk__client_t *) (ipc_providers->data) : NULL;
	}

	/*!
	* \internal
	* \brief Accept a client connection on a proxy IPC server
	*
	* \param[in] c Client's IPC connection
	* \param[in] uid Client's user ID
	* \param[in] gid Client's group ID
	* \param[in] ipc_channel Name of IPC server to proxy
	*
	* \return pcmk_ok on success, -errno on error
	*/
	static int32_t
	ipc_proxy_accept(qb_ipcs_connection_t * c, uid_t uid, gid_t gid, const char *ipc_channel)
	{
	pcmk__client_t *client;
	pcmk__client_t *ipc_proxy = ipc_proxy_get_provider();
	xmlNode *msg;

	if (ipc_proxy == NULL) {
	crm_warn("Cannot proxy IPC connection from uid %d gid %d to %s "
	"because not connected to cluster", uid, gid, ipc_channel);
	return -EREMOTEIO;
	}

	/* This new client is a local IPC client on a Pacemaker Remote controlled
	* node, needing to access cluster node IPC services.
	*/
	client = pcmk__new_client(c, uid, gid);
	if (client == NULL) {
	return -ENOMEM;
	}

	/* This ipc client is bound to a single ipc provider. If the
	* provider goes away, this client is disconnected */
	client->userdata = strdup(ipc_proxy->id);
	client->name = crm_strdup_printf("proxy-%s-%d-%.8s", ipc_channel, client->pid, client->id);

	/* Allow remote executor to distinguish between proxied local clients and
	* actual executor API clients
	*/
	pcmk__set_client_flags(client, pcmk__client_to_proxy);

	g_hash_table_insert(ipc_clients, client->id, client);

	msg = create_xml_node(NULL, T_LRMD_IPC_PROXY);
	crm_xml_add(msg, PCMK__XA_LRMD_IPC_OP, LRMD_IPC_OP_NEW);
	- crm_xml_add(msg, F_LRMD_IPC_IPC_SERVER, ipc_channel);
	+ crm_xml_add(msg, PCMK__XA_LRMD_IPC_SERVER, ipc_channel);
	crm_xml_add(msg, F_LRMD_IPC_SESSION, client->id);
	lrmd_server_send_notify(ipc_proxy, msg);
	free_xml(msg);
	crm_debug("Accepted IPC proxy connection (session ID %s) "
	"from uid %d gid %d on channel %s",
	client->id, uid, gid, ipc_channel);
	return 0;
	}

	static int32_t
	crmd_proxy_accept(qb_ipcs_connection_t * c, uid_t uid, gid_t gid)
	{
	return ipc_proxy_accept(c, uid, gid, CRM_SYSTEM_CRMD);
	}

	static int32_t
	attrd_proxy_accept(qb_ipcs_connection_t * c, uid_t uid, gid_t gid)
	{
	return ipc_proxy_accept(c, uid, gid, PCMK__VALUE_ATTRD);
	}

	static int32_t
	stonith_proxy_accept(qb_ipcs_connection_t * c, uid_t uid, gid_t gid)
	{
	return ipc_proxy_accept(c, uid, gid, "stonith-ng");
	}

	static int32_t
	pacemakerd_proxy_accept(qb_ipcs_connection_t * c, uid_t uid, gid_t gid)
	{
	return -EREMOTEIO;
	}

	static int32_t
	cib_proxy_accept_rw(qb_ipcs_connection_t * c, uid_t uid, gid_t gid)
	{
	return ipc_proxy_accept(c, uid, gid, PCMK__SERVER_BASED_RW);
	}

	static int32_t
	cib_proxy_accept_ro(qb_ipcs_connection_t * c, uid_t uid, gid_t gid)
	{
	return ipc_proxy_accept(c, uid, gid, PCMK__SERVER_BASED_RO);
	}

	void
	ipc_proxy_forward_client(pcmk__client_t ipc_proxy, xmlNode xml)
	{
	const char *session = crm_element_value(xml, F_LRMD_IPC_SESSION);
	const char *msg_type = crm_element_value(xml, PCMK__XA_LRMD_IPC_OP);
	xmlNode *msg = get_message_xml(xml, F_LRMD_IPC_MSG);
	pcmk__client_t *ipc_client;
	int rc = pcmk_rc_ok;

	/* If the IPC provider is acknowledging our shutdown request,
	* defuse the short exit timer to give the cluster time to
	* stop any resources we're running.
	*/
	if (pcmk__str_eq(msg_type, LRMD_IPC_OP_SHUTDOWN_ACK, pcmk__str_casei)) {
	handle_shutdown_ack();
	return;
	}

	if (pcmk__str_eq(msg_type, LRMD_IPC_OP_SHUTDOWN_NACK, pcmk__str_casei)) {
	handle_shutdown_nack();
	return;
	}

	ipc_client = pcmk__find_client_by_id(session);
	if (ipc_client == NULL) {
	xmlNode *msg = create_xml_node(NULL, T_LRMD_IPC_PROXY);
	crm_xml_add(msg, PCMK__XA_LRMD_IPC_OP, LRMD_IPC_OP_DESTROY);
	crm_xml_add(msg, F_LRMD_IPC_SESSION, session);
	lrmd_server_send_notify(ipc_proxy, msg);
	free_xml(msg);
	return;
	}

	/* This is an event or response from the ipc provider
	* going to the local ipc client.
	*
	* Looking at the chain of events.
	*
	* -----remote node----------------\|---- cluster node ------
	* ipc_client <--1--> this code
	* <--2--> pacemaker-controld:remote_proxy_cb/remote_proxy_relay_event()
	* <--3--> ipc server
	*
	* This function is receiving a msg from connection 2
	* and forwarding it to connection 1.
	*/

	if (pcmk__str_eq(msg_type, LRMD_IPC_OP_EVENT, pcmk__str_casei)) {
	crm_trace("Sending event to %s", ipc_client->id);
	rc = pcmk__ipc_send_xml(ipc_client, 0, msg, crm_ipc_server_event);

	} else if (pcmk__str_eq(msg_type, LRMD_IPC_OP_RESPONSE, pcmk__str_casei)) {
	int msg_id = 0;

	crm_element_value_int(xml, F_LRMD_IPC_MSG_ID, &msg_id);
	crm_trace("Sending response to %d - %s", ipc_client->request_id, ipc_client->id);
	rc = pcmk__ipc_send_xml(ipc_client, msg_id, msg, FALSE);

	CRM_LOG_ASSERT(msg_id == ipc_client->request_id);
	ipc_client->request_id = 0;

	} else if (pcmk__str_eq(msg_type, LRMD_IPC_OP_DESTROY, pcmk__str_casei)) {
	qb_ipcs_disconnect(ipc_client->ipcs);

	} else {
	crm_err("Unknown ipc proxy msg type %s" , msg_type);
	}

	if (rc != pcmk_rc_ok) {
	crm_warn("Could not proxy IPC to client %s: %s " CRM_XS " rc=%d",
	ipc_client->id, pcmk_rc_str(rc), rc);
	}
	}

	static int32_t
	ipc_proxy_dispatch(qb_ipcs_connection_t * c, void *data, size_t size)
	{
	uint32_t id = 0;
	uint32_t flags = 0;
	pcmk__client_t *client = pcmk__find_client(c);
	pcmk__client_t *ipc_proxy = pcmk__find_client_by_id(client->userdata);
	xmlNode *request = NULL;
	xmlNode *msg = NULL;

	if (!ipc_proxy) {
	qb_ipcs_disconnect(client->ipcs);
	return 0;
	}

	/* This is a request from the local ipc client going
	* to the ipc provider.
	*
	* Looking at the chain of events.
	*
	* -----remote node----------------\|---- cluster node ------
	* ipc_client <--1--> this code
	* <--2--> pacemaker-controld:remote_proxy_dispatch_internal()
	* <--3--> ipc server
	*
	* This function is receiving a request from connection
	* 1 and forwarding it to connection 2.
	*/
	request = pcmk__client_data2xml(client, data, &id, &flags);

	if (!request) {
	return 0;
	}

	CRM_CHECK(client != NULL, crm_err("Invalid client");
	free_xml(request); return FALSE);
	CRM_CHECK(client->id != NULL, crm_err("Invalid client: %p", client);
	free_xml(request); return FALSE);

	/* This ensures that synced request/responses happen over the event channel
	* in the controller, allowing the controller to process the messages async.
	*/
	pcmk__set_ipc_flags(flags, pcmk__client_name(client), crm_ipc_proxied);
	client->request_id = id;

	msg = create_xml_node(NULL, T_LRMD_IPC_PROXY);
	crm_xml_add(msg, PCMK__XA_LRMD_IPC_OP, LRMD_IPC_OP_REQUEST);
	crm_xml_add(msg, F_LRMD_IPC_SESSION, client->id);
	crm_xml_add(msg, F_LRMD_IPC_CLIENT, pcmk__client_name(client));
	crm_xml_add(msg, F_LRMD_IPC_USER, client->user);
	crm_xml_add_int(msg, F_LRMD_IPC_MSG_ID, id);
	crm_xml_add_int(msg, F_LRMD_IPC_MSG_FLAGS, flags);
	add_message_xml(msg, F_LRMD_IPC_MSG, request);
	lrmd_server_send_notify(ipc_proxy, msg);
	free_xml(request);
	free_xml(msg);

	return 0;
	}

	/*!
	* \internal
	* \brief Notify a proxy provider that we wish to shut down
	*
	* \param[in,out] ipc_proxy IPC client connection to proxy provider
	*
	* \return 0 on success, -1 on error
	*/
	int
	ipc_proxy_shutdown_req(pcmk__client_t *ipc_proxy)
	{
	xmlNode *msg = create_xml_node(NULL, T_LRMD_IPC_PROXY);
	int rc;

	crm_xml_add(msg, PCMK__XA_LRMD_IPC_OP, LRMD_IPC_OP_SHUTDOWN_REQ);

	/* We don't really have a session, but the controller needs this attribute
	* to recognize this as proxy communication.
	*/
	crm_xml_add(msg, F_LRMD_IPC_SESSION, "0");

	rc = (lrmd_server_send_notify(ipc_proxy, msg) != pcmk_rc_ok)? -1 : 0;
	free_xml(msg);
	return rc;
	}

	static int32_t
	ipc_proxy_closed(qb_ipcs_connection_t * c)
	{
	pcmk__client_t *client = pcmk__find_client(c);
	pcmk__client_t *ipc_proxy;

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

	ipc_proxy = pcmk__find_client_by_id(client->userdata);

	crm_trace("Connection %p", c);

	if (ipc_proxy) {
	xmlNode *msg = create_xml_node(NULL, T_LRMD_IPC_PROXY);
	crm_xml_add(msg, PCMK__XA_LRMD_IPC_OP, LRMD_IPC_OP_DESTROY);
	crm_xml_add(msg, F_LRMD_IPC_SESSION, client->id);
	lrmd_server_send_notify(ipc_proxy, msg);
	free_xml(msg);
	}

	g_hash_table_remove(ipc_clients, client->id);

	free(client->userdata);
	client->userdata = NULL;
	pcmk__free_client(client);
	return 0;
	}

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

	static struct qb_ipcs_service_handlers crmd_proxy_callbacks = {
	.connection_accept = crmd_proxy_accept,
	.connection_created = NULL,
	.msg_process = ipc_proxy_dispatch,
	.connection_closed = ipc_proxy_closed,
	.connection_destroyed = ipc_proxy_destroy
	};

	static struct qb_ipcs_service_handlers attrd_proxy_callbacks = {
	.connection_accept = attrd_proxy_accept,
	.connection_created = NULL,
	.msg_process = ipc_proxy_dispatch,
	.connection_closed = ipc_proxy_closed,
	.connection_destroyed = ipc_proxy_destroy
	};

	static struct qb_ipcs_service_handlers stonith_proxy_callbacks = {
	.connection_accept = stonith_proxy_accept,
	.connection_created = NULL,
	.msg_process = ipc_proxy_dispatch,
	.connection_closed = ipc_proxy_closed,
	.connection_destroyed = ipc_proxy_destroy
	};

	static struct qb_ipcs_service_handlers pacemakerd_proxy_callbacks = {
	.connection_accept = pacemakerd_proxy_accept,
	.connection_created = NULL,
	.msg_process = NULL,
	.connection_closed = NULL,
	.connection_destroyed = NULL
	};

	static struct qb_ipcs_service_handlers cib_proxy_callbacks_ro = {
	.connection_accept = cib_proxy_accept_ro,
	.connection_created = NULL,
	.msg_process = ipc_proxy_dispatch,
	.connection_closed = ipc_proxy_closed,
	.connection_destroyed = ipc_proxy_destroy
	};

	static struct qb_ipcs_service_handlers cib_proxy_callbacks_rw = {
	.connection_accept = cib_proxy_accept_rw,
	.connection_created = NULL,
	.msg_process = ipc_proxy_dispatch,
	.connection_closed = ipc_proxy_closed,
	.connection_destroyed = ipc_proxy_destroy
	};

	void
	ipc_proxy_add_provider(pcmk__client_t *ipc_proxy)
	{
	// Prepending ensures the most recent connection is always first
	ipc_providers = g_list_prepend(ipc_providers, ipc_proxy);
	}

	void
	ipc_proxy_remove_provider(pcmk__client_t *ipc_proxy)
	{
	GHashTableIter iter;
	pcmk__client_t *ipc_client = NULL;
	char *key = NULL;
	GList *remove_these = NULL;
	GList *gIter = NULL;

	ipc_providers = g_list_remove(ipc_providers, ipc_proxy);

	g_hash_table_iter_init(&iter, ipc_clients);
	while (g_hash_table_iter_next(&iter, (gpointer ) & key, (gpointer ) & ipc_client)) {
	const char *proxy_id = ipc_client->userdata;
	if (pcmk__str_eq(proxy_id, ipc_proxy->id, pcmk__str_casei)) {
	crm_info("ipc proxy connection for client %s pid %d destroyed because cluster node disconnected.",
	ipc_client->id, ipc_client->pid);
	/* we can't remove during the iteration, so copy items
	* to a list we can destroy later */
	remove_these = g_list_append(remove_these, ipc_client);
	}
	}

	for (gIter = remove_these; gIter != NULL; gIter = gIter->next) {
	ipc_client = gIter->data;

	// Disconnection callback will free the client here
	qb_ipcs_disconnect(ipc_client->ipcs);
	}

	/* just frees the list, not the elements in the list */
	g_list_free(remove_these);
	}

	void
	ipc_proxy_init(void)
	{
	ipc_clients = pcmk__strkey_table(NULL, NULL);

	pcmk__serve_based_ipc(&cib_ro, &cib_rw, &cib_shm, &cib_proxy_callbacks_ro,
	&cib_proxy_callbacks_rw);
	pcmk__serve_attrd_ipc(&attrd_ipcs, &attrd_proxy_callbacks);
	pcmk__serve_fenced_ipc(&stonith_ipcs, &stonith_proxy_callbacks);
	pcmk__serve_pacemakerd_ipc(&pacemakerd_ipcs, &pacemakerd_proxy_callbacks);
	crmd_ipcs = pcmk__serve_controld_ipc(&crmd_proxy_callbacks);
	if (crmd_ipcs == NULL) {
	crm_err("Failed to create controller: exiting and inhibiting respawn");
	crm_warn("Verify pacemaker and pacemaker_remote are not both enabled");
	crm_exit(CRM_EX_FATAL);
	}
	}

	void
	ipc_proxy_cleanup(void)
	{
	if (ipc_providers) {
	g_list_free(ipc_providers);
	ipc_providers = NULL;
	}
	if (ipc_clients) {
	g_hash_table_destroy(ipc_clients);
	ipc_clients = NULL;
	}
	pcmk__stop_based_ipc(cib_ro, cib_rw, cib_shm);
	qb_ipcs_destroy(attrd_ipcs);
	qb_ipcs_destroy(stonith_ipcs);
	qb_ipcs_destroy(pacemakerd_ipcs);
	qb_ipcs_destroy(crmd_ipcs);
	cib_ro = NULL;
	cib_rw = NULL;
	cib_shm = NULL;
	}
	diff --git a/include/crm/common/xml_names_internal.h b/include/crm/common/xml_names_internal.h
	index 0d77afa06e..d2f290f5db 100644
	--- a/include/crm/common/xml_names_internal.h
	+++ b/include/crm/common/xml_names_internal.h
	@@ -1,336 +1,337 @@
	/*
	* Copyright 2004-2024 the Pacemaker project contributors
	*
	* The version control history for this file may have further details.
	*
	* This source code is licensed under the GNU Lesser General Public License
	* version 2.1 or later (LGPLv2.1+) WITHOUT ANY WARRANTY.
	*/

	#ifndef PCMK__CRM_COMMON_XML_NAMES_INTERNAL__H
	# define PCMK__CRM_COMMON_XML_NAMES_INTERNAL__H

	#ifdef __cplusplus
	extern "C" {
	#endif

	/*
	* XML element names used only by internal code
	*/

	#define PCMK__XE_ACK "ack"
	#define PCMK__XE_ATTRIBUTES "attributes"
	#define PCMK__XE_CIB_CALLBACK "cib-callback"
	#define PCMK__XE_CIB_COMMAND "cib_command"
	#define PCMK__XE_CIB_REPLY "cib-reply"
	#define PCMK__XE_CIB_RESULT "cib_result"
	#define PCMK__XE_CIB_TRANSACTION "cib_transaction"
	#define PCMK__XE_COPY "copy"
	#define PCMK__XE_CRM_EVENT "crm_event"
	#define PCMK__XE_CRM_XML "crm_xml"
	#define PCMK__XE_DIV "div"
	#define PCMK__XE_DOWNED "downed"
	#define PCMK__XE_EXIT_NOTIFICATION "exit-notification"
	#define PCMK__XE_FAILED "failed"
	#define PCMK__XE_FAILED_UPDATE "failed_update"
	#define PCMK__XE_GENERATION_TUPLE "generation_tuple"
	#define PCMK__XE_LRM "lrm"
	#define PCMK__XE_LRM_RESOURCE "lrm_resource"
	#define PCMK__XE_LRM_RESOURCES "lrm_resources"
	#define PCMK__XE_LRM_RSC_OP "lrm_rsc_op"
	#define PCMK__XE_LRMD_ALERT "lrmd_alert"
	#define PCMK__XE_LRMD_RSC "lrmd_rsc"
	#define PCMK__XE_MAINTENANCE "maintenance"
	#define PCMK__XE_META "meta"
	#define PCMK__XE_NACK "nack"
	#define PCMK__XE_NODE_STATE "node_state"
	#define PCMK__XE_NOTIFY "notify"
	#define PCMK__XE_OPTIONS "options"
	#define PCMK__XE_PARAM "param"
	#define PCMK__XE_PING "ping"
	#define PCMK__XE_PING_RESPONSE "ping_response"
	#define PCMK__XE_PSEUDO_EVENT "pseudo_event"
	#define PCMK__XE_RSC_OP "rsc_op"
	#define PCMK__XE_SHUTDOWN "shutdown"
	#define PCMK__XE_SPAN "span"
	#define PCMK__XE_ST_ASYNC_TIMEOUT_VALUE "st-async-timeout-value"
	#define PCMK__XE_ST_DEVICE_ACTION "st_device_action"
	#define PCMK__XE_ST_DEVICE_ID "st_device_id"
	#define PCMK__XE_ST_HISTORY "st_history"
	#define PCMK__XE_ST_REPLY "st-reply"
	#define PCMK__XE_STONITH_COMMAND "stonith_command"
	#define PCMK__XE_TICKET_STATE "ticket_state"
	#define PCMK__XE_TRANSIENT_ATTRIBUTES "transient_attributes"
	#define PCMK__XE_TRANSITION_GRAPH "transition_graph"
	#define PCMK__XE_XPATH_QUERY "xpath-query"
	#define PCMK__XE_XPATH_QUERY_PATH "xpath-query-path"

	// @COMPAT Deprecated since 1.1.12
	#define PCMK__XE_ACL_USER "acl_user"

	/* @COMPAT Deprecate somehow. It's undocumented and behaves the same as
	* PCMK__XE_CIB in places where it's recognized.
	*/
	#define PCMK__XE_ALL "all"

	// @COMPAT Deprecated since 2.1.8
	#define PCMK__XE_CIB_GENERATION "cib_generation"

	// @COMPAT Deprecated since 2.1.8
	#define PCMK__XE_CIB_UPDATE "cib_update"

	// @COMPAT Deprecated since 2.1.7
	#define PCMK__XE_DIFF_ADDED "diff-added"

	// @COMPAT Deprecated since 2.1.7
	#define PCMK__XE_DIFF_REMOVED "diff-removed"

	// @COMPAT Deprecated since 1.0.8 (commit 4cb100f)
	#define PCMK__XE_LIFETIME "lifetime"

	/* @COMPAT Deprecated since 2.0.0; alias for <clone> with PCMK_META_PROMOTABLE
	* set to "true"
	*/
	#define PCMK__XE_PROMOTABLE_LEGACY "master"

	// @COMPAT Support for rkt is deprecated since 2.1.8
	#define PCMK__XE_RKT "rkt"

	// @COMPAT Deprecated since 1.1.12
	#define PCMK__XE_ROLE_REF "role_ref"


	/*
	* XML attribute names used only by internal code
	*/

	#define PCMK__XA_ATTR_CLEAR_INTERVAL "attr_clear_interval"
	#define PCMK__XA_ATTR_CLEAR_OPERATION "attr_clear_operation"
	#define PCMK__XA_ATTR_DAMPENING "attr_dampening"
	#define PCMK__XA_ATTR_HOST "attr_host"
	#define PCMK__XA_ATTR_HOST_ID "attr_host_id"
	#define PCMK__XA_ATTR_IS_PRIVATE "attr_is_private"
	#define PCMK__XA_ATTR_IS_REMOTE "attr_is_remote"
	#define PCMK__XA_ATTR_NAME "attr_name"
	#define PCMK__XA_ATTR_REGEX "attr_regex"
	#define PCMK__XA_ATTR_RESOURCE "attr_resource"
	#define PCMK__XA_ATTR_SECTION "attr_section"
	#define PCMK__XA_ATTR_SET "attr_set"
	#define PCMK__XA_ATTR_SET_TYPE "attr_set_type"
	#define PCMK__XA_ATTR_SYNC_POINT "attr_sync_point"
	#define PCMK__XA_ATTR_USER "attr_user"
	#define PCMK__XA_ATTR_VALUE "attr_value"
	#define PCMK__XA_ATTR_VERSION "attr_version"
	#define PCMK__XA_ATTR_WRITER "attr_writer"
	#define PCMK__XA_ATTRD_IS_FORCE_WRITE "attrd_is_force_write"
	#define PCMK__XA_CALL_ID "call-id"
	#define PCMK__XA_CIB_CALLDATA "cib_calldata"
	#define PCMK__XA_CIB_CALLID "cib_callid"
	#define PCMK__XA_CIB_CALLOPT "cib_callopt"
	#define PCMK__XA_CIB_CLIENTID "cib_clientid"
	#define PCMK__XA_CIB_CLIENTNAME "cib_clientname"
	#define PCMK__XA_CIB_DELEGATED_FROM "cib_delegated_from"
	#define PCMK__XA_CIB_HOST "cib_host"
	#define PCMK__XA_CIB_ISREPLYTO "cib_isreplyto"
	#define PCMK__XA_CIB_NOTIFY_ACTIVATE "cib_notify_activate"
	#define PCMK__XA_CIB_NOTIFY_TYPE "cib_notify_type"
	#define PCMK__XA_CIB_OP "cib_op"
	#define PCMK__XA_CIB_PING_ID "cib_ping_id"
	#define PCMK__XA_CIB_RC "cib_rc"
	#define PCMK__XA_CIB_SCHEMA_MAX "cib_schema_max"
	#define PCMK__XA_CIB_SECTION "cib_section"
	#define PCMK__XA_CIB_UPDATE "cib_update"
	#define PCMK__XA_CIB_UPDATE_RESULT "cib_update_result"
	#define PCMK__XA_CIB_UPGRADE_RC "cib_upgrade_rc"
	#define PCMK__XA_CIB_USER "cib_user"
	#define PCMK__XA_CLIENT_NAME "client_name"
	#define PCMK__XA_CLIENT_UUID "client_uuid"
	#define PCMK__XA_CONFIG_ERRORS "config-errors"
	#define PCMK__XA_CONFIG_WARNINGS "config-warnings"
	#define PCMK__XA_CONFIRM "confirm"
	#define PCMK__XA_CONNECTION_HOST "connection_host"
	#define PCMK__XA_CONTENT "content"
	#define PCMK__XA_CRMD_STATE "crmd_state"
	#define PCMK__XA_CRM_HOST_TO "crm_host_to"
	#define PCMK__XA_CRM_LIMIT_MAX "crm-limit-max"
	#define PCMK__XA_CRM_LIMIT_MODE "crm-limit-mode"
	#define PCMK__XA_CRM_SUBSYSTEM "crm_subsystem"
	#define PCMK__XA_CRM_SYS_FROM "crm_sys_from"
	#define PCMK__XA_CRM_SYS_TO "crm_sys_to"
	#define PCMK__XA_CRM_TASK "crm_task"
	#define PCMK__XA_CRM_TGRAPH_IN "crm-tgraph-in"
	#define PCMK__XA_CRM_USER "crm_user"
	#define PCMK__XA_DC_LEAVING "dc-leaving"
	#define PCMK__XA_DIGEST "digest"
	#define PCMK__XA_ELECTION_AGE_SEC "election-age-sec"
	#define PCMK__XA_ELECTION_AGE_NANO_SEC "election-age-nano-sec"
	#define PCMK__XA_ELECTION_ID "election-id"
	#define PCMK__XA_ELECTION_OWNER "election-owner"
	#define PCMK__XA_GRANTED "granted"
	#define PCMK__XA_GRAPH_ERRORS "graph-errors"
	#define PCMK__XA_GRAPH_WARNINGS "graph-warnings"
	#define PCMK__XA_HIDDEN "hidden"
	#define PCMK__XA_HTTP_EQUIV "http-equiv"
	#define PCMK__XA_IN_CCM "in_ccm"
	#define PCMK__XA_JOIN "join"
	#define PCMK__XA_JOIN_ID "join_id"
	#define PCMK__XA_LINE "line"
	#define PCMK__XA_LONG_ID "long-id"
	#define PCMK__XA_LRMD_ALERT_ID "lrmd_alert_id"
	#define PCMK__XA_LRMD_ALERT_PATH "lrmd_alert_path"
	#define PCMK__XA_LRMD_CALLDATA "lrmd_calldata"
	#define PCMK__XA_LRMD_CALLID "lrmd_callid"
	#define PCMK__XA_LRMD_CALLOPT "lrmd_callopt"
	#define PCMK__XA_LRMD_CLASS "lrmd_class"
	#define PCMK__XA_LRMD_CLIENTID "lrmd_clientid"
	#define PCMK__XA_LRMD_CLIENTNAME "lrmd_clientname"
	#define PCMK__XA_LRMD_EXEC_OP_STATUS "lrmd_exec_op_status"
	#define PCMK__XA_LRMD_EXEC_RC "lrmd_exec_rc"
	#define PCMK__XA_LRMD_EXEC_TIME "lrmd_exec_time"
	#define PCMK__XA_LRMD_IPC_OP "lrmd_ipc_op"
	+#define PCMK__XA_LRMD_IPC_SERVER "lrmd_ipc_server"
	#define PCMK__XA_LRMD_IS_IPC_PROVIDER "lrmd_is_ipc_provider"
	#define PCMK__XA_LRMD_OP "lrmd_op"
	#define PCMK__XA_LRMD_ORIGIN "lrmd_origin"
	#define PCMK__XA_LRMD_PROTOCOL_VERSION "lrmd_protocol_version"
	#define PCMK__XA_LRMD_PROVIDER "lrmd_provider"
	#define PCMK__XA_LRMD_QUEUE_TIME "lrmd_queue_time"
	#define PCMK__XA_LRMD_RC "lrmd_rc"
	#define PCMK__XA_LRMD_RCCHANGE_TIME "lrmd_rcchange_time"
	#define PCMK__XA_LRMD_REMOTE_MSG_ID "lrmd_remote_msg_id"
	#define PCMK__XA_LRMD_REMOTE_MSG_TYPE "lrmd_remote_msg_type"
	#define PCMK__XA_LRMD_RSC_ACTION "lrmd_rsc_action"
	#define PCMK__XA_LRMD_RSC_DELETED "lrmd_rsc_deleted"
	#define PCMK__XA_LRMD_RSC_EXIT_REASON "lrmd_rsc_exit_reason"
	#define PCMK__XA_LRMD_RSC_ID "lrmd_rsc_id"
	#define PCMK__XA_LRMD_RSC_INTERVAL "lrmd_rsc_interval"
	#define PCMK__XA_LRMD_RSC_OUTPUT "lrmd_rsc_output"
	#define PCMK__XA_LRMD_RSC_START_DELAY "lrmd_rsc_start_delay"
	#define PCMK__XA_LRMD_RSC_USERDATA_STR "lrmd_rsc_userdata_str"
	#define PCMK__XA_LRMD_RUN_TIME "lrmd_run_time"
	#define PCMK__XA_LRMD_TIMEOUT "lrmd_timeout"
	#define PCMK__XA_LRMD_TYPE "lrmd_type"
	#define PCMK__XA_LRMD_WATCHDOG "lrmd_watchdog"
	#define PCMK__XA_MAJOR_VERSION "major_version"
	#define PCMK__XA_MINOR_VERSION "minor_version"
	#define PCMK__XA_MODE "mode"
	#define PCMK__XA_MOON "moon"
	#define PCMK__XA_NAMESPACE "namespace"
	#define PCMK__XA_NODE_FENCED "node_fenced"
	#define PCMK__XA_NODE_IN_MAINTENANCE "node_in_maintenance"
	#define PCMK__XA_NODE_START_STATE "node_start_state"
	#define PCMK__XA_NODE_STATE "node_state"
	#define PCMK__XA_OP_DIGEST "op-digest"
	#define PCMK__XA_OP_FORCE_RESTART "op-force-restart"
	#define PCMK__XA_OP_RESTART_DIGEST "op-restart-digest"
	#define PCMK__XA_OP_SECURE_DIGEST "op-secure-digest"
	#define PCMK__XA_OP_SECURE_PARAMS "op-secure-params"
	#define PCMK__XA_OP_STATUS "op-status"
	#define PCMK__XA_OPERATION_KEY "operation_key"
	#define PCMK__XA_ORIGINAL_CIB_OP "original_cib_op"
	#define PCMK__XA_PACEMAKERD_STATE "pacemakerd_state"
	#define PCMK__XA_PASSWORD "password"
	#define PCMK__XA_PRIORITY "priority"
	#define PCMK__XA_RC_CODE "rc-code"
	#define PCMK__XA_REAP "reap"

	/* Actions to be executed on Pacemaker Remote nodes are routed through the
	* controller on the cluster node hosting the remote connection. That cluster
	* node is considered the router node for the action.
	*/
	#define PCMK__XA_ROUTER_NODE "router_node"

	#define PCMK__XA_RSC_ID "rsc-id"
	#define PCMK__XA_RSC_PROVIDES "rsc_provides"
	#define PCMK__XA_SCHEMA "schema"
	#define PCMK__XA_SCHEMAS "schemas"
	#define PCMK__XA_SRC "src"
	#define PCMK__XA_ST_ACTION_DISALLOWED "st_action_disallowed"
	#define PCMK__XA_ST_ACTION_TIMEOUT "st_action_timeout"
	#define PCMK__XA_ST_AVAILABLE_DEVICES "st-available-devices"
	#define PCMK__XA_ST_CALLID "st_callid"
	#define PCMK__XA_ST_CALLDATA "st_calldata"
	#define PCMK__XA_ST_CALLOPT "st_callopt"
	#define PCMK__XA_ST_CLIENTID "st_clientid"
	#define PCMK__XA_ST_CLIENTNAME "st_clientname"
	#define PCMK__XA_ST_CLIENTNODE "st_clientnode"
	#define PCMK__XA_ST_DATE "st_date"
	#define PCMK__XA_ST_DATE_NSEC "st_date_nsec"
	#define PCMK__XA_ST_DELAY "st_delay"
	#define PCMK__XA_ST_DELAY_BASE "st_delay_base"
	#define PCMK__XA_ST_DELAY_MAX "st_delay_max"
	#define PCMK__XA_ST_DELEGATE "st_delegate"
	#define PCMK__XA_ST_DEVICE_ACTION "st_device_action"
	#define PCMK__XA_ST_DEVICE_ID "st_device_id"
	#define PCMK__XA_ST_DEVICE_SUPPORT_FLAGS "st_device_support_flags"
	#define PCMK__XA_ST_DIFFERENTIAL "st_differential"
	#define PCMK__XA_ST_MONITOR_VERIFIED "st_monitor_verified"
	#define PCMK__XA_ST_NOTIFY_ACTIVATE "st_notify_activate"
	#define PCMK__XA_ST_NOTIFY_DEACTIVATE "st_notify_deactivate"
	#define PCMK__XA_ST_OP "st_op"
	#define PCMK__XA_ST_OP_MERGED "st_op_merged"
	#define PCMK__XA_ST_ORIGIN "st_origin"
	#define PCMK__XA_ST_OUTPUT "st_output"
	#define PCMK__XA_ST_RC "st_rc"
	#define PCMK__XA_ST_REMOTE_OP "st_remote_op"
	#define PCMK__XA_ST_REMOTE_OP_RELAY "st_remote_op_relay"
	#define PCMK__XA_ST_REQUIRED "st_required"
	#define PCMK__XA_ST_STATE "st_state"
	#define PCMK__XA_ST_TARGET "st_target"
	#define PCMK__XA_ST_TIMEOUT "st_timeout"
	#define PCMK__XA_ST_TOLERANCE "st_tolerance"
	#define PCMK__XA_SUBT "subt" // subtype
	#define PCMK__XA_T "t" // type
	#define PCMK__XA_TRANSITION_KEY "transition-key"
	#define PCMK__XA_TRANSITION_MAGIC "transition-magic"
	#define PCMK__XA_UPTIME "uptime"

	// @COMPAT Deprecated since 2.1.8
	#define PCMK__XA_CIB_OBJECT "cib_object"

	// @COMPAT Deprecated since 2.1.8
	#define PCMK__XA_CIB_OBJECT_TYPE "cib_object_type"

	// @COMPAT Deprecated since 1.1.12; used with legacy CIB updates
	#define PCMK__XA_CIB_LOCAL_NOTIFY_ID "cib_local_notify_id"

	// @COMPAT Deprecated since 1.1.12; used with legacy CIB updates
	#define PCMK__XA_CIB_UPDATE_DIFF "cib_update_diff"

	// @COMPAT Used only with v1 patchsets
	#define PCMK__XA_CRM_DIFF_MARKER "__crm_diff_marker__"

	// @COMPAT Deprecated since 2.1.5
	#define PCMK__XA_FIRST_INSTANCE "first-instance"

	// @COMPAT Deprecated since 2.1.7
	#define PCMK__XA_ORDERING "ordering"

	// @COMPAT Deprecated alias for PCMK_XA_PROMOTED_MAX since 2.0.0
	#define PCMK__XA_PROMOTED_MAX_LEGACY "masters"

	// @COMPAT Deprecated alias for PCMK_XA_PROMOTED_ONLY since 2.0.0
	#define PCMK__XA_PROMOTED_ONLY_LEGACY "master_only"

	// @COMPAT Deprecated since 1.1.12
	#define PCMK__XA_REF "ref"

	// @COMPAT Deprecated since 2.1.6
	#define PCMK__XA_REPLACE "replace"

	// @COMPAT Deprecated alias for \c PCMK_XA_AUTOMATIC since 1.1.14
	#define PCMK__XA_REQUIRED "required"

	// @COMPAT Deprecated since 2.1.5
	#define PCMK__XA_RSC_INSTANCE "rsc-instance"

	// @COMPAT Deprecated since 2.1.5
	#define PCMK__XA_THEN_INSTANCE "then-instance"

	// @COMPAT Deprecated since 2.1.5
	#define PCMK__XA_WITH_RSC_INSTANCE "with-rsc-instance"

	#ifdef __cplusplus
	}
	#endif

	#endif // PCMK__CRM_COMMON_XML_NAMES_INTERNAL__H

File Metadata

Mime Type: text/x-diff
Expires: Sun, Jul 20, 9:17 PM (16 h, 58 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 2081518
Default Alt Text: (57 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions