No OneTemporary
Actions

Size

31 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/daemons/attrd/attrd_corosync.c b/daemons/attrd/attrd_corosync.c
	index 06db113db7..6b8fbfe490 100644
	--- a/daemons/attrd/attrd_corosync.c
	+++ b/daemons/attrd/attrd_corosync.c
	@@ -1,605 +1,603 @@
	/*
	* Copyright 2013-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 <stdbool.h>
	#include <stdint.h>
	#include <stdlib.h>

	#include <crm/cluster.h>
	#include <crm/cluster/internal.h>
	#include <crm/common/logging.h>
	#include <crm/common/results.h>
	#include <crm/common/strings_internal.h>
	#include <crm/common/xml.h>

	#include "pacemaker-attrd.h"

	static xmlNode *
	attrd_confirmation(int callid)
	{
	xmlNode *node = create_xml_node(NULL, __func__);

	crm_xml_add(node, PCMK__XA_T, PCMK__VALUE_ATTRD);
	crm_xml_add(node, PCMK__XA_SRC, get_local_node_name());
	crm_xml_add(node, PCMK_XA_TASK, PCMK__ATTRD_CMD_CONFIRM);
	crm_xml_add_int(node, PCMK__XA_CALL_ID, callid);

	return node;
	}

	static void
	attrd_peer_message(crm_node_t peer, xmlNode xml)
	{
	const char *election_op = crm_element_value(xml, PCMK__XA_CRM_TASK);

	if (election_op) {
	attrd_handle_election_op(peer, xml);
	return;
	}

	if (attrd_shutting_down(false)) {
	/* If we're shutting down, we want to continue responding to election
	* ops as long as we're a cluster member (because our vote may be
	* needed). Ignore all other messages.
	*/
	return;

	} else {
	pcmk__request_t request = {
	.ipc_client = NULL,
	.ipc_id = 0,
	.ipc_flags = 0,
	.peer = peer->uname,
	.xml = xml,
	.call_options = 0,
	.result = PCMK__UNKNOWN_RESULT,
	};

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

	attrd_handle_request(&request);

	/* Having finished handling the request, check to see if the originating
	* peer requested confirmation. If so, send that confirmation back now.
	*/
	if (pcmk__xe_attr_is_true(xml, PCMK__XA_CONFIRM) &&
	!pcmk__str_eq(request.op, PCMK__ATTRD_CMD_CONFIRM, pcmk__str_none)) {
	int callid = 0;
	xmlNode *reply = NULL;

	/* Add the confirmation ID for the message we are confirming to the
	* response so the originating peer knows what they're a confirmation
	* for.
	*/
	crm_element_value_int(xml, PCMK__XA_CALL_ID, &callid);
	reply = attrd_confirmation(callid);

	/* And then send the confirmation back to the originating peer. This
	* ends up right back in this same function (attrd_peer_message) on the
	* peer where it will have to do something with a PCMK__XA_CONFIRM type
	* message.
	*/
	crm_debug("Sending %s a confirmation", peer->uname);
	attrd_send_message(peer, reply, false);
	free_xml(reply);
	}

	pcmk__reset_request(&request);
	}
	}

	static void
	attrd_cpg_dispatch(cpg_handle_t handle,
	const struct cpg_name *groupName,
	uint32_t nodeid, uint32_t pid, void *msg, size_t msg_len)
	{
	uint32_t kind = 0;
	xmlNode *xml = NULL;
	const char *from = NULL;
	char *data = pcmk_message_common_cs(handle, nodeid, pid, msg, &kind, &from);

	if(data == NULL) {
	return;
	}

	if (kind == crm_class_cluster) {
	xml = string2xml(data);
	}

	if (xml == NULL) {
	crm_err("Bad message of class %d received from %s[%u]: '%.120s'", kind, from, nodeid, data);
	} else {
	attrd_peer_message(pcmk__get_node(nodeid, from, NULL,
	pcmk__node_search_cluster),
	xml);
	}

	free_xml(xml);
	free(data);
	}

	static void
	attrd_cpg_destroy(gpointer unused)
	{
	if (attrd_shutting_down(false)) {
	crm_info("Disconnected from Corosync process group");

	} else {
	crm_crit("Lost connection to Corosync process group, shutting down");
	attrd_exit_status = CRM_EX_DISCONNECT;
	attrd_shutdown(0);
	}
	}

	/*!
	* \internal
	- * \brief Override an attribute sync with a local value
	+ * \brief Broadcast an update for a single attribute value
	*
	- * Broadcast the local node's value for an attribute that's different from the
	- * value provided in a peer's attribute synchronization response. This ensures a
	- * node's values for itself take precedence and all peers are kept in sync.
	- *
	- * \param[in] a Attribute entry to override
	- *
	- * \return Local instance of attribute value
	+ * \param[in] a Attribute to broadcast
	+ * \param[in] v Attribute value to broadcast
	*/
	-static attribute_value_t *
	-broadcast_local_value(const attribute_t *a)
	+void
	+attrd_broadcast_value(const attribute_t a, const attribute_value_t v)
	{
	- attribute_value_t *v = g_hash_table_lookup(a->values, attrd_cluster->uname);
	- xmlNode *sync = create_xml_node(NULL, __func__);
	+ xmlNode *op = create_xml_node(NULL, PCMK_XE_OP);

	- crm_xml_add(sync, PCMK_XA_TASK, PCMK__ATTRD_CMD_SYNC_RESPONSE);
	- attrd_add_value_xml(sync, a, v, false);
	- attrd_send_message(NULL, sync, false);
	- free_xml(sync);
	- return v;
	+ crm_xml_add(op, PCMK_XA_TASK, PCMK__ATTRD_CMD_UPDATE);
	+ attrd_add_value_xml(op, a, v, false);
	+ attrd_send_message(NULL, op, false);
	+ free_xml(op);
	}

	#define state_text(state) pcmk__s((state), "in unknown state")

	static void
	attrd_peer_change_cb(enum crm_status_type kind, crm_node_t peer, const void data)
	{
	bool gone = false;
	bool is_remote = pcmk_is_set(peer->flags, crm_remote_node);

	switch (kind) {
	case crm_status_uname:
	crm_debug("%s node %s is now %s",
	(is_remote? "Remote" : "Cluster"),
	peer->uname, state_text(peer->state));
	break;

	case crm_status_processes:
	if (!pcmk_is_set(peer->processes, crm_get_cluster_proc())) {
	gone = true;
	}
	crm_debug("Node %s is %s a peer",
	peer->uname, (gone? "no longer" : "now"));
	break;

	case crm_status_nstate:
	crm_debug("%s node %s is now %s (was %s)",
	(is_remote? "Remote" : "Cluster"),
	peer->uname, state_text(peer->state), state_text(data));
	if (pcmk__str_eq(peer->state, CRM_NODE_MEMBER, pcmk__str_casei)) {
	/* If we're the writer, send new peers a list of all attributes
	* (unless it's a remote node, which doesn't run its own attrd)
	*/
	if (attrd_election_won()
	&& !pcmk_is_set(peer->flags, crm_remote_node)) {
	attrd_peer_sync(peer);
	}
	} else {
	// Remove all attribute values associated with lost nodes
	attrd_peer_remove(peer->uname, false, "loss");
	gone = true;
	}
	break;
	}

	// Remove votes from cluster nodes that leave, in case election in progress
	if (gone && !is_remote) {
	attrd_remove_voter(peer);
	attrd_remove_peer_protocol_ver(peer->uname);
	attrd_do_not_expect_from_peer(peer->uname);
	}
	}

	static void
	record_peer_nodeid(attribute_value_t v, const char host)
	{
	crm_node_t *known_peer = pcmk__get_node(v->nodeid, host, NULL,
	pcmk__node_search_cluster);

	crm_trace("Learned %s has node id %s", known_peer->uname, known_peer->uuid);
	if (attrd_election_won()) {
	attrd_write_attributes(attrd_write_changed);
	}
	}

	#define readable_value(rv_v) pcmk__s((rv_v)->current, "(unset)")

	#define readable_peer(p) \
	(((p) == NULL)? "all peers" : pcmk__s((p)->uname, "unknown peer"))

	static void
	update_attr_on_host(attribute_t a, const crm_node_t peer, const xmlNode *xml,
	const char attr, const char value, const char *host,
	bool filter)
	{
	int is_remote = 0;
	bool changed = false;
	attribute_value_t *v = NULL;

	// Create entry for value if not already existing
	v = g_hash_table_lookup(a->values, host);
	if (v == NULL) {
	v = calloc(1, sizeof(attribute_value_t));
	CRM_ASSERT(v != NULL);

	pcmk__str_update(&v->nodename, host);
	g_hash_table_replace(a->values, v->nodename, v);
	}

	// If value is for a Pacemaker Remote node, remember that
	crm_element_value_int(xml, PCMK__XA_ATTR_IS_REMOTE, &is_remote);
	if (is_remote) {
	attrd_set_value_flags(v, attrd_value_remote);
	CRM_ASSERT(crm_remote_peer_get(host) != NULL);
	}

	// Check whether the value changed
	changed = !pcmk__str_eq(v->current, value, pcmk__str_casei);

	if (changed && filter && pcmk__str_eq(host, attrd_cluster->uname,
	pcmk__str_casei)) {
	-
	+ /* Broadcast the local value for an attribute that differs from the
	+ * value provided in a peer's attribute synchronization response. This
	+ * ensures a node's values for itself take precedence and all peers are
	+ * kept in sync.
	+ */
	+ v = g_hash_table_lookup(a->values, attrd_cluster->uname);
	crm_notice("%s[%s]: local value '%s' takes priority over '%s' from %s",
	attr, host, readable_value(v), value, peer->uname);
	- v = broadcast_local_value(a);
	+ attrd_broadcast_value(a, v);

	} else if (changed) {
	crm_notice("Setting %s[%s]%s%s: %s -> %s "
	CRM_XS " from %s with %s write delay",
	attr, host, a->set_type ? " in " : "",
	pcmk__s(a->set_type, ""), readable_value(v),
	pcmk__s(value, "(unset)"), peer->uname,
	(a->timeout_ms == 0)? "no" : pcmk__readable_interval(a->timeout_ms));
	pcmk__str_update(&v->current, value);
	attrd_set_attr_flags(a, attrd_attr_changed);

	if (pcmk__str_eq(host, attrd_cluster->uname, pcmk__str_casei)
	&& pcmk__str_eq(attr, PCMK__NODE_ATTR_SHUTDOWN, pcmk__str_none)) {

	if (!pcmk__str_eq(value, "0", pcmk__str_null_matches)) {
	attrd_set_requesting_shutdown();

	} else {
	attrd_clear_requesting_shutdown();
	}
	}

	// Write out new value or start dampening timer
	if (a->timeout_ms && a->timer) {
	crm_trace("Delaying write of %s %s for dampening",
	attr, pcmk__readable_interval(a->timeout_ms));
	mainloop_timer_start(a->timer);
	} else {
	attrd_write_or_elect_attribute(a);
	}

	} else {
	int is_force_write = 0;

	crm_element_value_int(xml, PCMK__XA_ATTRD_IS_FORCE_WRITE,
	&is_force_write);

	if (is_force_write == 1 && a->timeout_ms && a->timer) {
	/* Save forced writing and set change flag. */
	/* The actual attribute is written by Writer after election. */
	crm_trace("%s[%s] from %s is unchanged (%s), forcing write",
	attr, host, peer->uname, pcmk__s(value, "unset"));
	attrd_set_attr_flags(a, attrd_attr_force_write);
	} else {
	crm_trace("%s[%s] from %s is unchanged (%s)",
	attr, host, peer->uname, pcmk__s(value, "unset"));
	}
	}

	// This allows us to later detect local values that peer doesn't know about
	attrd_set_value_flags(v, attrd_value_from_peer);

	/* If this is a cluster node whose node ID we are learning, remember it */
	if ((v->nodeid == 0) && !pcmk_is_set(v->flags, attrd_value_remote)
	&& (crm_element_value_int(xml, PCMK__XA_ATTR_HOST_ID,
	(int*)&v->nodeid) == 0) && (v->nodeid > 0)) {
	record_peer_nodeid(v, host);
	}
	}

	static void
	attrd_peer_update_one(const crm_node_t peer, xmlNode xml, bool filter)
	{
	attribute_t *a = NULL;
	const char *attr = crm_element_value(xml, PCMK__XA_ATTR_NAME);
	const char *value = crm_element_value(xml, PCMK__XA_ATTR_VALUE);
	const char *host = crm_element_value(xml, PCMK__XA_ATTR_HOST);

	if (attr == NULL) {
	crm_warn("Could not update attribute: peer did not specify name");
	return;
	}

	a = attrd_populate_attribute(xml, attr);
	if (a == NULL) {
	return;
	}

	if (host == NULL) {
	// If no host was specified, update all hosts
	GHashTableIter vIter;

	crm_debug("Setting %s for all hosts to %s", attr, value);
	xml_remove_prop(xml, PCMK__XA_ATTR_HOST_ID);
	g_hash_table_iter_init(&vIter, a->values);

	while (g_hash_table_iter_next(&vIter, (gpointer *) & host, NULL)) {
	update_attr_on_host(a, peer, xml, attr, value, host, filter);
	}

	} else {
	// Update attribute value for the given host
	update_attr_on_host(a, peer, xml, attr, value, host, filter);
	}

	/* If this is a message from some attrd instance broadcasting its protocol
	* version, check to see if it's a new minimum version.
	*/
	if (pcmk__str_eq(attr, CRM_ATTR_PROTOCOL, pcmk__str_none)) {
	attrd_update_minimum_protocol_ver(peer->uname, value);
	}
	}

	static void
	broadcast_unseen_local_values(void)
	{
	GHashTableIter aIter;
	GHashTableIter vIter;
	attribute_t *a = NULL;
	attribute_value_t *v = NULL;
	xmlNode *sync = NULL;

	g_hash_table_iter_init(&aIter, attributes);
	while (g_hash_table_iter_next(&aIter, NULL, (gpointer *) & a)) {

	g_hash_table_iter_init(&vIter, a->values);
	while (g_hash_table_iter_next(&vIter, NULL, (gpointer *) & v)) {

	if (!pcmk_is_set(v->flags, attrd_value_from_peer)
	&& pcmk__str_eq(v->nodename, attrd_cluster->uname,
	pcmk__str_casei)) {
	crm_trace("* %s[%s]='%s' is local-only",
	a->id, v->nodename, readable_value(v));
	if (sync == NULL) {
	sync = create_xml_node(NULL, __func__);
	crm_xml_add(sync, PCMK_XA_TASK, PCMK__ATTRD_CMD_SYNC_RESPONSE);
	}
	attrd_add_value_xml(sync, a, v, a->timeout_ms && a->timer);
	}
	}
	}

	if (sync != NULL) {
	crm_debug("Broadcasting local-only values");
	attrd_send_message(NULL, sync, false);
	free_xml(sync);
	}
	}

	int
	attrd_cluster_connect(void)
	{
	attrd_cluster = pcmk_cluster_new();

	attrd_cluster->destroy = attrd_cpg_destroy;
	attrd_cluster->cpg.cpg_deliver_fn = attrd_cpg_dispatch;
	attrd_cluster->cpg.cpg_confchg_fn = pcmk_cpg_membership;

	crm_set_status_callback(&attrd_peer_change_cb);

	if (crm_cluster_connect(attrd_cluster) == FALSE) {
	crm_err("Cluster connection failed");
	return -ENOTCONN;
	}
	return pcmk_ok;
	}

	void
	attrd_peer_clear_failure(pcmk__request_t *request)
	{
	xmlNode *xml = request->xml;
	const char *rsc = crm_element_value(xml, PCMK__XA_ATTR_RESOURCE);
	const char *host = crm_element_value(xml, PCMK__XA_ATTR_HOST);
	const char *op = crm_element_value(xml, PCMK__XA_ATTR_CLEAR_OPERATION);
	const char *interval_spec = crm_element_value(xml,
	PCMK__XA_ATTR_CLEAR_INTERVAL);
	guint interval_ms = 0U;
	char *attr = NULL;
	GHashTableIter iter;
	regex_t regex;

	crm_node_t *peer = pcmk__get_node(0, request->peer, NULL,
	pcmk__node_search_cluster);

	pcmk_parse_interval_spec(interval_spec, &interval_ms);

	if (attrd_failure_regex(&regex, rsc, op, interval_ms) != pcmk_ok) {
	crm_info("Ignoring invalid request to clear failures for %s",
	pcmk__s(rsc, "all resources"));
	return;
	}

	crm_xml_add(xml, PCMK_XA_TASK, PCMK__ATTRD_CMD_UPDATE);

	/* Make sure value is not set, so we delete */
	xml_remove_prop(xml, PCMK__XA_ATTR_VALUE);

	g_hash_table_iter_init(&iter, attributes);
	while (g_hash_table_iter_next(&iter, (gpointer *) &attr, NULL)) {
	if (regexec(&regex, attr, 0, NULL, 0) == 0) {
	crm_trace("Matched %s when clearing %s",
	attr, pcmk__s(rsc, "all resources"));
	crm_xml_add(xml, PCMK__XA_ATTR_NAME, attr);
	attrd_peer_update(peer, xml, host, false);
	}
	}
	regfree(&regex);
	}

	/*!
	* \internal
	* \brief Load attributes from a peer sync response
	*
	* \param[in] peer Peer that sent sync response
	* \param[in] peer_won Whether peer is the attribute writer
	* \param[in,out] xml Request XML
	*/
	void
	attrd_peer_sync_response(const crm_node_t peer, bool peer_won, xmlNode xml)
	{
	crm_info("Processing " PCMK__ATTRD_CMD_SYNC_RESPONSE " from %s",
	peer->uname);

	if (peer_won) {
	/* Initialize the "seen" flag for all attributes to cleared, so we can
	* detect attributes that local node has but the writer doesn't.
	*/
	attrd_clear_value_seen();
	}

	// Process each attribute update in the sync response
	for (xmlNode *child = pcmk__xml_first_child(xml); child != NULL;
	child = pcmk__xml_next(child)) {
	attrd_peer_update(peer, child,
	crm_element_value(child, PCMK__XA_ATTR_HOST), true);
	}

	if (peer_won) {
	/* If any attributes are still not marked as seen, the writer doesn't
	* know about them, so send all peers an update with them.
	*/
	broadcast_unseen_local_values();
	}
	}

	/*!
	* \internal
	* \brief Remove all attributes and optionally peer cache entries for a node
	*
	* \param[in] host Name of node to purge
	* \param[in] uncache If true, remove node from peer caches
	* \param[in] source Who requested removal (only used for logging)
	*/
	void
	attrd_peer_remove(const char host, bool uncache, const char source)
	{
	attribute_t *a = NULL;
	GHashTableIter aIter;

	CRM_CHECK(host != NULL, return);
	crm_notice("Removing all %s attributes for node %s "
	CRM_XS " %s reaping node from cache",
	host, source, (uncache? "and" : "without"));

	g_hash_table_iter_init(&aIter, attributes);
	while (g_hash_table_iter_next(&aIter, NULL, (gpointer *) & a)) {
	if(g_hash_table_remove(a->values, host)) {
	crm_debug("Removed %s[%s] for peer %s", a->id, host, source);
	}
	}

	if (uncache) {
	pcmk__purge_node_from_cache(host, 0);
	}
	}

	/*!
	* \internal
	* \brief Send all known attributes and values to a peer
	*
	* \param[in] peer Peer to send sync to (if NULL, broadcast to all peers)
	*/
	void
	attrd_peer_sync(crm_node_t *peer)
	{
	GHashTableIter aIter;
	GHashTableIter vIter;

	attribute_t *a = NULL;
	attribute_value_t *v = NULL;
	xmlNode *sync = create_xml_node(NULL, __func__);

	crm_xml_add(sync, PCMK_XA_TASK, PCMK__ATTRD_CMD_SYNC_RESPONSE);

	g_hash_table_iter_init(&aIter, attributes);
	while (g_hash_table_iter_next(&aIter, NULL, (gpointer *) & a)) {
	g_hash_table_iter_init(&vIter, a->values);
	while (g_hash_table_iter_next(&vIter, NULL, (gpointer *) & v)) {
	crm_debug("Syncing %s[%s]='%s' to %s",
	a->id, v->nodename, readable_value(v),
	readable_peer(peer));
	attrd_add_value_xml(sync, a, v, false);
	}
	}

	crm_debug("Syncing values to %s", readable_peer(peer));
	attrd_send_message(peer, sync, false);
	free_xml(sync);
	}

	void
	attrd_peer_update(const crm_node_t peer, xmlNode xml, const char *host,
	bool filter)
	{
	bool handle_sync_point = false;

	CRM_CHECK((peer != NULL) && (xml != NULL), return);
	if (xml->children != NULL) {
	for (xmlNode *child = first_named_child(xml, PCMK_XE_OP); child != NULL;
	child = crm_next_same_xml(child)) {
	attrd_copy_xml_attributes(xml, child);
	attrd_peer_update_one(peer, child, filter);

	if (attrd_request_has_sync_point(child)) {
	handle_sync_point = true;
	}
	}

	} else {
	attrd_peer_update_one(peer, xml, filter);

	if (attrd_request_has_sync_point(xml)) {
	handle_sync_point = true;
	}
	}

	/* If the update XML specified that the client wanted to wait for a sync
	* point, process that now.
	*/
	if (handle_sync_point) {
	crm_trace("Hit local sync point for attribute update");
	attrd_ack_waitlist_clients(attrd_sync_point_local, xml);
	}
	}
	diff --git a/daemons/attrd/pacemaker-attrd.h b/daemons/attrd/pacemaker-attrd.h
	index 21917ccc7e..f55c5afd90 100644
	--- a/daemons/attrd/pacemaker-attrd.h
	+++ b/daemons/attrd/pacemaker-attrd.h
	@@ -1,255 +1,256 @@
	/*
	* Copyright 2013-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.
	*/

	#ifndef PACEMAKER_ATTRD__H
	# define PACEMAKER_ATTRD__H

	#include <regex.h>
	#include <glib.h>
	#include <crm/crm.h>
	#include <crm/cluster.h>
	#include <crm/cluster/election_internal.h>
	#include <crm/common/messages_internal.h>
	#include <crm/cib/internal.h>

	/*
	* Legacy attrd (all pre-1.1.11 Pacemaker versions, plus all versions when used
	* with the no-longer-supported CMAN or corosync-plugin stacks) is unversioned.
	*
	* With atomic attrd, each attrd will send ATTRD_PROTOCOL_VERSION with every
	* peer request and reply. As of Pacemaker 2.0.0, at start-up each attrd will
	* also set a private attribute for itself with its version, so any attrd can
	* determine the minimum version supported by all peers.
	*
	* Protocol Pacemaker Significant changes
	* -------- --------- -------------------
	* 1 1.1.11 PCMK__ATTRD_CMD_UPDATE (PCMK__XA_ATTR_NAME only),
	* PCMK__ATTRD_CMD_PEER_REMOVE, PCMK__ATTRD_CMD_REFRESH,
	* PCMK__ATTRD_CMD_FLUSH, PCMK__ATTRD_CMD_SYNC_RESPONSE
	* 1 1.1.13 PCMK__ATTRD_CMD_UPDATE (with PCMK__XA_ATTR_REGEX),
	* PCMK__ATTRD_CMD_QUERY
	* 1 1.1.15 PCMK__ATTRD_CMD_UPDATE_BOTH,
	* PCMK__ATTRD_CMD_UPDATE_DELAY
	* 2 1.1.17 PCMK__ATTRD_CMD_CLEAR_FAILURE
	* 3 2.1.1 PCMK__ATTRD_CMD_SYNC_RESPONSE indicates remote nodes
	* 4 2.1.5 Multiple attributes can be updated in a single IPC
	* message
	* 5 2.1.5 Peers can request confirmation of a sent message
	* 6 2.1.7 PCMK__ATTRD_CMD_PEER_REMOVE supports PCMK__XA_REAP
	*/
	#define ATTRD_PROTOCOL_VERSION "6"

	#define ATTRD_SUPPORTS_MULTI_MESSAGE(x) ((x) >= 4)
	#define ATTRD_SUPPORTS_CONFIRMATION(x) ((x) >= 5)

	#define attrd_send_ack(client, id, flags) \
	pcmk__ipc_send_ack((client), (id), (flags), PCMK__XE_ACK, \
	ATTRD_PROTOCOL_VERSION, CRM_EX_INDETERMINATE)

	void attrd_init_mainloop(void);
	void attrd_run_mainloop(void);

	void attrd_set_requesting_shutdown(void);
	void attrd_clear_requesting_shutdown(void);
	void attrd_free_waitlist(void);
	bool attrd_shutting_down(bool if_requested);
	void attrd_shutdown(int nsig);
	void attrd_init_ipc(void);
	void attrd_ipc_fini(void);

	int attrd_cib_connect(int max_retry);
	void attrd_cib_disconnect(void);
	void attrd_cib_init(void);
	void attrd_cib_erase_transient_attrs(const char *node);

	bool attrd_value_needs_expansion(const char *value);
	int attrd_expand_value(const char value, const char old_value);

	/* regular expression to clear failures of all resources */
	#define ATTRD_RE_CLEAR_ALL \
	"^(" PCMK__FAIL_COUNT_PREFIX "\|" PCMK__LAST_FAILURE_PREFIX ")-"

	/* regular expression to clear failure of all operations for one resource
	* (format takes resource name)
	*
	* @COMPAT attributes set < 1.1.17:
	* also match older attributes that do not have the operation part
	*/
	#define ATTRD_RE_CLEAR_ONE ATTRD_RE_CLEAR_ALL "%s(#.+_[0-9]+)?$"

	/* regular expression to clear failure of one operation for one resource
	* (format takes resource name, operation name, and interval)
	*
	* @COMPAT attributes set < 1.1.17:
	* also match older attributes that do not have the operation part
	*/
	#define ATTRD_RE_CLEAR_OP ATTRD_RE_CLEAR_ALL "%s(#%s_%u)?$"

	int attrd_failure_regex(regex_t regex, const char rsc, const char *op,
	guint interval_ms);

	extern cib_t *the_cib;
	extern crm_exit_t attrd_exit_status;

	/* Alerts */

	extern lrmd_t *the_lrmd;
	extern crm_trigger_t *attrd_config_read;

	void attrd_lrmd_disconnect(void);
	gboolean attrd_read_options(gpointer user_data);
	int attrd_send_attribute_alert(const char *node, int nodeid,
	const char attr, const char value);

	// Elections
	void attrd_election_init(void);
	void attrd_election_fini(void);
	void attrd_start_election_if_needed(void);
	bool attrd_election_won(void);
	void attrd_handle_election_op(const crm_node_t peer, xmlNode xml);
	bool attrd_check_for_new_writer(const crm_node_t peer, const xmlNode xml);
	void attrd_declare_winner(void);
	void attrd_remove_voter(const crm_node_t *peer);
	void attrd_xml_add_writer(xmlNode *xml);

	enum attrd_attr_flags {
	attrd_attr_none = 0U,
	attrd_attr_changed = (1U << 0), // Attribute value has changed since last write
	attrd_attr_uuid_missing = (1U << 1), // Whether we know we're missing a peer UUID
	attrd_attr_is_private = (1U << 2), // Whether to keep this attribute out of the CIB
	attrd_attr_force_write = (1U << 3), // Update attribute by ignoring delay
	};

	typedef struct attribute_s {
	char uuid; / TODO: Remove if at all possible */
	char *id;
	char *set_id;
	char *set_type;
	GHashTable *values;
	int update;
	int timeout_ms;
	uint32_t flags;

	mainloop_timer_t *timer;

	char *user;
	} attribute_t;

	#define attrd_set_attr_flags(attr, flags_to_set) do { \
	(attr)->flags = pcmk__set_flags_as(__func__, __LINE__, \
	LOG_TRACE, "Value for attribute", (attr)->id, \
	(attr)->flags, (flags_to_set), #flags_to_set); \
	} while (0)

	#define attrd_clear_attr_flags(attr, flags_to_clear) do { \
	(attr)->flags = pcmk__clear_flags_as(__func__, __LINE__, \
	LOG_TRACE, "Value for attribute", (attr)->id, \
	(attr)->flags, (flags_to_clear), #flags_to_clear); \
	} while (0)

	enum attrd_value_flags {
	attrd_value_none = 0U,
	attrd_value_remote = (1U << 0), // Value is for Pacemaker Remote node
	attrd_value_from_peer = (1U << 1), // Value is from peer sync response
	};

	typedef struct attribute_value_s {
	uint32_t nodeid;
	char *nodename;
	char *current;
	char *requested;
	uint32_t flags; // Group of attrd_value_flags
	} attribute_value_t;

	#define attrd_set_value_flags(attr_value, flags_to_set) do { \
	(attr_value)->flags = pcmk__set_flags_as(__func__, __LINE__, \
	LOG_TRACE, "Value for node", (attr_value)->nodename, \
	(attr_value)->flags, (flags_to_set), #flags_to_set); \
	} while (0)

	#define attrd_clear_value_flags(attr_value, flags_to_clear) do { \
	(attr_value)->flags = pcmk__clear_flags_as(__func__, __LINE__, \
	LOG_TRACE, "Value for node", (attr_value)->nodename, \
	(attr_value)->flags, (flags_to_clear), #flags_to_clear); \
	} while (0)

	extern crm_cluster_t *attrd_cluster;
	extern GHashTable *attributes;
	extern GHashTable *peer_protocol_vers;

	#define CIB_OP_TIMEOUT_S 120

	int attrd_cluster_connect(void);
	+void attrd_broadcast_value(const attribute_t a, const attribute_value_t v);
	void attrd_peer_update(const crm_node_t peer, xmlNode xml, const char *host,
	bool filter);
	void attrd_peer_sync(crm_node_t *peer);
	void attrd_peer_remove(const char host, bool uncache, const char source);
	void attrd_peer_clear_failure(pcmk__request_t *request);
	void attrd_peer_sync_response(const crm_node_t *peer, bool peer_won,
	xmlNode *xml);

	void attrd_broadcast_protocol(void);
	xmlNode attrd_client_peer_remove(pcmk__request_t request);
	xmlNode attrd_client_clear_failure(pcmk__request_t request);
	xmlNode attrd_client_update(pcmk__request_t request);
	xmlNode attrd_client_refresh(pcmk__request_t request);
	xmlNode attrd_client_query(pcmk__request_t request);
	gboolean attrd_send_message(crm_node_t node, xmlNode data, bool confirm);

	xmlNode attrd_add_value_xml(xmlNode parent, const attribute_t *a,
	const attribute_value_t *v, bool force_write);
	void attrd_clear_value_seen(void);
	void attrd_free_attribute(gpointer data);
	void attrd_free_attribute_value(gpointer data);
	attribute_t attrd_populate_attribute(xmlNode xml, const char *attr);
	char attrd_set_id(const attribute_t attr, const char *node_state_id);
	char attrd_nvpair_id(const attribute_t attr, const char *node_state_id);

	enum attrd_write_options {
	attrd_write_changed = 0,
	attrd_write_all = (1 << 0),
	attrd_write_no_delay = (1 << 1),
	};

	void attrd_write_attributes(uint32_t options);
	void attrd_write_or_elect_attribute(attribute_t *a);

	extern int minimum_protocol_version;
	void attrd_remove_peer_protocol_ver(const char *host);
	void attrd_update_minimum_protocol_ver(const char host, const char value);

	mainloop_timer_t attrd_add_timer(const char id, int timeout_ms, attribute_t *attr);

	void attrd_unregister_handlers(void);
	void attrd_handle_request(pcmk__request_t *request);

	enum attrd_sync_point {
	attrd_sync_point_local,
	attrd_sync_point_cluster,
	};

	typedef int (attrd_confirmation_action_fn)(xmlNode );

	void attrd_add_client_to_waitlist(pcmk__request_t *request);
	void attrd_ack_waitlist_clients(enum attrd_sync_point sync_point, const xmlNode *xml);
	int attrd_cluster_sync_point_update(xmlNode *xml);
	void attrd_do_not_expect_from_peer(const char *host);
	void attrd_do_not_wait_for_client(pcmk__client_t *client);
	void attrd_expect_confirmations(pcmk__request_t *request, attrd_confirmation_action_fn fn);
	void attrd_free_confirmations(void);
	void attrd_handle_confirmation(int callid, const char *host);
	void attrd_remove_client_from_waitlist(pcmk__client_t *client);
	const char attrd_request_sync_point(xmlNode xml);
	bool attrd_request_has_sync_point(xmlNode *xml);

	void attrd_copy_xml_attributes(xmlNode src, xmlNode dest);

	extern gboolean stand_alone;

	#endif /* PACEMAKER_ATTRD__H */

File Metadata

Mime Type: text/x-diff
Expires: Mon, Dec 23, 12:08 PM (1 d, 2 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1128307
Default Alt Text: (31 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions