No OneTemporary
Actions

Size

43 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/include/crm/cluster/internal.h b/include/crm/cluster/internal.h
	index f915ae3d2a..9da9ccf8d2 100644
	--- a/include/crm/cluster/internal.h
	+++ b/include/crm/cluster/internal.h
	@@ -1,476 +1,477 @@
	/*
	* Copyright (C) 2004 Andrew Beekhof <andrew@beekhof.net>
	*
	* This program is free software; you can redistribute it and/or
	* modify it under the terms of the GNU General Public
	* License as published by the Free Software Foundation; either
	* version 2 of the License, or (at your option) any later version.
	*
	* This software is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	* General Public License for more details.
	*
	* You should have received a copy of the GNU General Public
	* License along with this library; if not, write to the Free Software
	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
	*/

	#ifndef CRM_CLUSTER_INTERNAL__H
	# define CRM_CLUSTER_INTERNAL__H

	# include <crm/cluster.h>

	# define AIS_IPC_NAME "ais-crm-ipc"
	# define AIS_IPC_MESSAGE_SIZE 8192*128
	# define CRM_MESSAGE_IPC_ACK 0

	# ifndef INTERFACE_MAX
	# define INTERFACE_MAX 2 /* from the private coroapi.h header */
	# endif

	typedef struct crm_ais_host_s AIS_Host;
	typedef struct crm_ais_msg_s AIS_Message;

	struct crm_ais_host_s {
	uint32_t id;
	uint32_t pid;
	gboolean local;
	enum crm_ais_msg_types type;
	uint32_t size;
	char uname[MAX_NAME];

	} __attribute__ ((packed));

	struct crm_ais_msg_s {
	cs_ipc_header_response_t header __attribute__ ((aligned(8)));
	uint32_t id;
	gboolean is_compressed;

	AIS_Host host;
	AIS_Host sender;

	uint32_t size;
	uint32_t compressed_size;
	/* 584 bytes */
	char data[0];

	} __attribute__ ((packed));

	struct crm_ais_nodeid_resp_s {
	cs_ipc_header_response_t header __attribute__ ((aligned(8)));
	uint32_t id;
	uint32_t counter;
	char uname[MAX_NAME];
	char cname[MAX_NAME];
	} __attribute__ ((packed));

	struct crm_ais_quorum_resp_s {
	cs_ipc_header_response_t header __attribute__ ((aligned(8)));
	uint64_t id;
	uint32_t votes;
	uint32_t expected_votes;
	uint32_t quorate;
	} __attribute__ ((packed));

	/* INDENT-OFF */
	enum crm_proc_flag {
	crm_proc_none = 0x00000001,
	/* These values are sent over the network by the legacy plugin
	* Therefor changing any of these values is going to break compatability
	*
	* So don't
	*/

	/* 3 messaging types */
	crm_proc_heartbeat = 0x01000000,
	crm_proc_plugin = 0x00000002,
	crm_proc_cpg = 0x04000000,

	crm_proc_lrmd = 0x00000010,
	crm_proc_cib = 0x00000100,
	crm_proc_crmd = 0x00000200,
	crm_proc_attrd = 0x00001000,

	crm_proc_stonithd = 0x00002000,
	crm_proc_stonith_ng= 0x00100000,

	crm_proc_pe = 0x00010000,
	crm_proc_te = 0x00020000,

	crm_proc_mgmtd = 0x00040000,
	};
	/* INDENT-ON */

	/*!
	* \internal
	* \brief Return the process bit corresponding to the current cluster stack
	*
	* \return Process flag if detectable, otherwise 0
	*/
	static inline uint32_t
	crm_get_cluster_proc()
	{
	switch (get_cluster_type()) {
	case pcmk_cluster_corosync:
	case pcmk_cluster_cman:
	return crm_proc_cpg;

	case pcmk_cluster_heartbeat:
	return crm_proc_heartbeat;

	case pcmk_cluster_classic_ais:
	return crm_proc_plugin;

	default:
	break;
	}
	return crm_proc_none;
	}

	static inline const char *
	peer2text(enum crm_proc_flag proc)
	{
	const char *text = "unknown";

	if (proc == (crm_proc_crmd \| crm_get_cluster_proc())) {
	return "peer";
	}

	switch (proc) {
	case crm_proc_none:
	text = "none";
	break;
	case crm_proc_plugin:
	text = "ais";
	break;
	case crm_proc_heartbeat:
	text = "heartbeat";
	break;
	case crm_proc_cib:
	text = "cib";
	break;
	case crm_proc_crmd:
	text = "crmd";
	break;
	case crm_proc_pe:
	text = "pengine";
	break;
	case crm_proc_te:
	text = "tengine";
	break;
	case crm_proc_lrmd:
	text = "lrmd";
	break;
	case crm_proc_attrd:
	text = "attrd";
	break;
	case crm_proc_stonithd:
	text = "stonithd";
	break;
	case crm_proc_stonith_ng:
	text = "stonith-ng";
	break;
	case crm_proc_mgmtd:
	text = "mgmtd";
	break;
	case crm_proc_cpg:
	text = "corosync-cpg";
	break;
	}
	return text;
	}

	static inline enum crm_proc_flag
	text2proc(const char *proc)
	{
	/* We only care about these two so far */

	if (proc && strcmp(proc, "cib") == 0) {
	return crm_proc_cib;
	} else if (proc && strcmp(proc, "crmd") == 0) {
	return crm_proc_crmd;
	}

	return crm_proc_none;
	}

	static inline const char *
	ais_dest(const struct crm_ais_host_s *host)
	{
	if (host->local) {
	return "local";
	} else if (host->size > 0) {
	return host->uname;
	} else {
	return "<all>";
	}
	}

	# define ais_data_len(msg) (msg->is_compressed?msg->compressed_size:msg->size)

	static inline AIS_Message *
	ais_msg_copy(const AIS_Message * source)
	{
	AIS_Message *target = malloc(sizeof(AIS_Message) + ais_data_len(source));

	if(target) {
	memcpy(target, source, sizeof(AIS_Message));
	memcpy(target->data, source->data, ais_data_len(target));
	}
	return target;
	}

	/*
	typedef enum {
	CS_OK = 1,
	CS_ERR_LIBRARY = 2,
	CS_ERR_VERSION = 3,
	CS_ERR_INIT = 4,
	CS_ERR_TIMEOUT = 5,
	CS_ERR_TRY_AGAIN = 6,
	CS_ERR_INVALID_PARAM = 7,
	CS_ERR_NO_MEMORY = 8,
	CS_ERR_BAD_HANDLE = 9,
	CS_ERR_BUSY = 10,
	CS_ERR_ACCESS = 11,
	CS_ERR_NOT_EXIST = 12,
	CS_ERR_NAME_TOO_LONG = 13,
	CS_ERR_EXIST = 14,
	CS_ERR_NO_SPACE = 15,
	CS_ERR_INTERRUPT = 16,
	CS_ERR_NAME_NOT_FOUND = 17,
	CS_ERR_NO_RESOURCES = 18,
	CS_ERR_NOT_SUPPORTED = 19,
	CS_ERR_BAD_OPERATION = 20,
	CS_ERR_FAILED_OPERATION = 21,
	CS_ERR_MESSAGE_ERROR = 22,
	CS_ERR_QUEUE_FULL = 23,
	CS_ERR_QUEUE_NOT_AVAILABLE = 24,
	CS_ERR_BAD_FLAGS = 25,
	CS_ERR_TOO_BIG = 26,
	CS_ERR_NO_SECTIONS = 27,
	CS_ERR_CONTEXT_NOT_FOUND = 28,
	CS_ERR_TOO_MANY_GROUPS = 30,
	CS_ERR_SECURITY = 100
	} cs_error_t;
	*/
	static inline const char *
	ais_error2text(int error)
	{
	const char *text = "unknown";

	# if SUPPORT_COROSYNC
	switch (error) {
	case CS_OK:
	text = "OK";
	break;
	case CS_ERR_LIBRARY:
	text = "Library error";
	break;
	case CS_ERR_VERSION:
	text = "Version error";
	break;
	case CS_ERR_INIT:
	text = "Initialization error";
	break;
	case CS_ERR_TIMEOUT:
	text = "Timeout";
	break;
	case CS_ERR_TRY_AGAIN:
	text = "Try again";
	break;
	case CS_ERR_INVALID_PARAM:
	text = "Invalid parameter";
	break;
	case CS_ERR_NO_MEMORY:
	text = "No memory";
	break;
	case CS_ERR_BAD_HANDLE:
	text = "Bad handle";
	break;
	case CS_ERR_BUSY:
	text = "Busy";
	break;
	case CS_ERR_ACCESS:
	text = "Access error";
	break;
	case CS_ERR_NOT_EXIST:
	text = "Doesn't exist";
	break;
	case CS_ERR_NAME_TOO_LONG:
	text = "Name too long";
	break;
	case CS_ERR_EXIST:
	text = "Exists";
	break;
	case CS_ERR_NO_SPACE:
	text = "No space";
	break;
	case CS_ERR_INTERRUPT:
	text = "Interrupt";
	break;
	case CS_ERR_NAME_NOT_FOUND:
	text = "Name not found";
	break;
	case CS_ERR_NO_RESOURCES:
	text = "No resources";
	break;
	case CS_ERR_NOT_SUPPORTED:
	text = "Not supported";
	break;
	case CS_ERR_BAD_OPERATION:
	text = "Bad operation";
	break;
	case CS_ERR_FAILED_OPERATION:
	text = "Failed operation";
	break;
	case CS_ERR_MESSAGE_ERROR:
	text = "Message error";
	break;
	case CS_ERR_QUEUE_FULL:
	text = "Queue full";
	break;
	case CS_ERR_QUEUE_NOT_AVAILABLE:
	text = "Queue not available";
	break;
	case CS_ERR_BAD_FLAGS:
	text = "Bad flags";
	break;
	case CS_ERR_TOO_BIG:
	text = "To big";
	break;
	case CS_ERR_NO_SECTIONS:
	text = "No sections";
	break;
	}
	# endif
	return text;
	}

	static inline const char *
	msg_type2text(enum crm_ais_msg_types type)
	{
	const char *text = "unknown";

	switch (type) {
	case crm_msg_none:
	text = "unknown";
	break;
	case crm_msg_ais:
	text = "ais";
	break;
	case crm_msg_cib:
	text = "cib";
	break;
	case crm_msg_crmd:
	text = "crmd";
	break;
	case crm_msg_pe:
	text = "pengine";
	break;
	case crm_msg_te:
	text = "tengine";
	break;
	case crm_msg_lrmd:
	text = "lrmd";
	break;
	case crm_msg_attrd:
	text = "attrd";
	break;
	case crm_msg_stonithd:
	text = "stonithd";
	break;
	case crm_msg_stonith_ng:
	text = "stonith-ng";
	break;
	}
	return text;
	}

	enum crm_ais_msg_types text2msg_type(const char *text);
	char get_ais_data(const AIS_Message msg);
	gboolean check_message_sanity(const AIS_Message * msg, const char *data);

	# if SUPPORT_HEARTBEAT
	extern ll_cluster_t *heartbeat_cluster;
	gboolean send_ha_message(ll_cluster_t * hb_conn, xmlNode * msg,
	const char *node, gboolean force_ordered);
	gboolean ha_msg_dispatch(ll_cluster_t * cluster_conn, gpointer user_data);

	gboolean register_heartbeat_conn(crm_cluster_t * cluster);
	xmlNode convert_ha_message(xmlNode parent, HA_Message * msg, const char *field);
	gboolean ccm_have_quorum(oc_ed_t event);
	const char *ccm_event_name(oc_ed_t event);
	crm_node_t crm_update_ccm_node(const oc_ev_membership_t oc, int offset, const char *state,
	uint64_t seq);

	gboolean heartbeat_initialize_nodelist(void cluster, gboolean force_member, xmlNode xml_parent);
	# endif

	# if SUPPORT_COROSYNC

	gboolean send_cpg_iov(struct iovec * iov);

	# if SUPPORT_PLUGIN
	char *classic_node_name(uint32_t nodeid);
	void plugin_handle_membership(AIS_Message *msg);
	bool send_plugin_text(int class, struct iovec *iov);
	# else
	char corosync_node_name(uint64_t /cmap_handle_t */ cmap_handle, uint32_t nodeid);
	char *corosync_cluster_name(void);
	int corosync_cmap_has_config(const char *prefix);
	# endif

	gboolean corosync_initialize_nodelist(void cluster, gboolean force_member, xmlNode xml_parent);

	gboolean send_cluster_message_cs(xmlNode * msg, gboolean local,
	crm_node_t * node, enum crm_ais_msg_types dest);

	enum cluster_type_e find_corosync_variant(void);

	void terminate_cs_connection(crm_cluster_t * cluster);
	gboolean init_cs_connection(crm_cluster_t * cluster);
	gboolean init_cs_connection_once(crm_cluster_t * cluster);
	# endif

	# ifdef SUPPORT_CMAN
	char *cman_node_name(uint32_t nodeid);
	# endif

	enum crm_quorum_source {
	crm_quorum_cman,
	crm_quorum_corosync,
	crm_quorum_pacemaker,
	};

	int get_corosync_id(int id, const char *uuid);
	char get_corosync_uuid(crm_node_t peer);
	enum crm_quorum_source get_quorum_source(void);

	crm_node_t crm_update_peer(const char source, unsigned int id, uint64_t born,
	uint64_t seen, int32_t votes, uint32_t children,
	const char uuid, const char uname,
	const char addr, const char state);
	crm_node_t crm_update_peer_proc(const char source, crm_node_t * peer,
	uint32_t flag, const char *status);
	crm_node_t crm_update_peer_state(const char source, crm_node_t * node,
	const char *state, int membership);

	+void crm_update_peer_uname(crm_node_t node, const char uname);
	void crm_update_peer_expected(const char source, crm_node_t node, const char *expected);
	void crm_reap_unseen_nodes(uint64_t ring_id);

	gboolean init_cman_connection(gboolean(*dispatch) (unsigned long long, gboolean),
	void (*destroy) (gpointer));

	gboolean cluster_connect_quorum(gboolean(*dispatch) (unsigned long long, gboolean),
	void (*destroy) (gpointer));

	void set_node_uuid(const char uname, const char uuid);

	gboolean node_name_is_valid(const char key, const char name);

	crm_node_t * crm_find_peer_full(unsigned int id, const char *uname, int flags);
	crm_node_t * crm_find_peer(unsigned int id, const char *uname);

	#endif
	diff --git a/lib/cluster/membership.c b/lib/cluster/membership.c
	index aef7f99b6d..3ec2c251f5 100644
	--- a/lib/cluster/membership.c
	+++ b/lib/cluster/membership.c
	@@ -1,936 +1,954 @@
	/*
	* Copyright (C) 2004 Andrew Beekhof <andrew@beekhof.net>
	*
	* This library is free software; you can redistribute it and/or
	* modify it under the terms of the GNU Lesser General Public
	* License as published by the Free Software Foundation; either
	* version 2.1 of the License, or (at your option) any later version.
	*
	* This library is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	* Lesser General Public License for more details.
	*
	* You should have received a copy of the GNU Lesser General Public
	* License along with this library; if not, write to the Free Software
	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
	*/
	#include <crm_internal.h>

	#ifndef _GNU_SOURCE
	# define _GNU_SOURCE
	#endif

	#include <sys/param.h>
	#include <sys/types.h>
	#include <stdio.h>
	#include <unistd.h>
	#include <string.h>
	#include <glib.h>
	#include <crm/common/ipc.h>
	#include <crm/cluster/internal.h>
	#include <crm/msg_xml.h>
	#include <crm/stonith-ng.h>

	GHashTable *crm_peer_cache = NULL;
	GHashTable *crm_remote_peer_cache = NULL;
	unsigned long long crm_peer_seq = 0;
	gboolean crm_have_quorum = FALSE;
	static gboolean crm_autoreap = TRUE;

	int
	crm_remote_peer_cache_size(void)
	{
	if (crm_remote_peer_cache == NULL) {
	return 0;
	}
	return g_hash_table_size(crm_remote_peer_cache);
	}

	void
	crm_remote_peer_cache_add(const char *node_name)
	{
	crm_node_t *node = g_hash_table_lookup(crm_remote_peer_cache, node_name);

	if (node == NULL) {
	crm_trace("added %s to remote cache", node_name);
	node = calloc(1, sizeof(crm_node_t));
	node->flags = crm_remote_node;
	CRM_ASSERT(node);
	node->uname = strdup(node_name);
	node->uuid = strdup(node_name);
	node->state = strdup(CRM_NODE_MEMBER);
	g_hash_table_replace(crm_remote_peer_cache, node->uname, node);
	}
	}

	void
	crm_remote_peer_cache_remove(const char *node_name)
	{
	g_hash_table_remove(crm_remote_peer_cache, node_name);
	}

	static void
	remote_cache_refresh_helper(xmlNode cib, const char xpath, const char *field)
	{
	const char *remote = NULL;
	crm_node_t *node = NULL;
	xmlXPathObjectPtr xpathObj = NULL;
	int max = 0;
	int lpc = 0;

	xpathObj = xpath_search(cib, xpath);
	max = numXpathResults(xpathObj);
	for (lpc = 0; lpc < max; lpc++) {
	xmlNode *xml = getXpathResult(xpathObj, lpc);

	CRM_LOG_ASSERT(xml != NULL);
	if(xml != NULL) {
	remote = crm_element_value(xml, field);
	}

	if (remote) {
	crm_trace("added %s to remote cache", remote);
	node = calloc(1, sizeof(crm_node_t));
	node->flags = crm_remote_node;
	CRM_ASSERT(node);
	node->uname = strdup(remote);
	node->uuid = strdup(remote);
	node->state = strdup(CRM_NODE_MEMBER);
	g_hash_table_replace(crm_remote_peer_cache, node->uname, node);
	}
	}
	freeXpathObject(xpathObj);
	}

	/* search string to find CIB resources entries for guest nodes */
	#define XPATH_GUEST_NODE_CONFIG \
	"//" XML_TAG_CIB "//" XML_CIB_TAG_CONFIGURATION "//" XML_CIB_TAG_RESOURCE \
	"//" XML_TAG_META_SETS "//" XML_CIB_TAG_NVPAIR \
	"[@name='" XML_RSC_ATTR_REMOTE_NODE "']"

	/* search string to find CIB resources entries for remote nodes */
	#define XPATH_REMOTE_NODE_CONFIG \
	"//" XML_TAG_CIB "//" XML_CIB_TAG_CONFIGURATION "//" XML_CIB_TAG_RESOURCE \
	"[@type='remote'][@provider='pacemaker']"

	/* search string to find CIB node status entries for pacemaker_remote nodes */
	#define XPATH_REMOTE_NODE_STATUS \
	"//" XML_TAG_CIB "//" XML_CIB_TAG_STATUS "//" XML_CIB_TAG_STATE \
	"[@" XML_NODE_IS_REMOTE "='true']"

	/*!
	* \brief Repopulate the remote peer cache based on CIB XML
	*
	* \param[in] xmlNode CIB XML to parse
	*/
	void crm_remote_peer_cache_refresh(xmlNode *cib)
	{
	g_hash_table_remove_all(crm_remote_peer_cache);

	/* remote nodes associated with a cluster resource */
	remote_cache_refresh_helper(cib, XPATH_GUEST_NODE_CONFIG, "value");

	/* baremetal nodes defined by connection resources*/
	remote_cache_refresh_helper(cib, XPATH_REMOTE_NODE_CONFIG, "id");

	/* baremetal nodes we have seen in the config that may or may not have connection
	* resources associated with them anymore */
	remote_cache_refresh_helper(cib, XPATH_REMOTE_NODE_STATUS, "id");
	}

	gboolean
	crm_is_peer_active(const crm_node_t * node)
	{
	if(node == NULL) {
	return FALSE;
	}

	if (is_set(node->flags, crm_remote_node)) {
	/* remote nodes are never considered active members. This
	* guarantees they will never be considered for DC membership.*/
	return FALSE;
	}
	#if SUPPORT_COROSYNC
	if (is_openais_cluster()) {
	return crm_is_corosync_peer_active(node);
	}
	#endif
	#if SUPPORT_HEARTBEAT
	if (is_heartbeat_cluster()) {
	return crm_is_heartbeat_peer_active(node);
	}
	#endif
	crm_err("Unhandled cluster type: %s", name_for_cluster_type(get_cluster_type()));
	return FALSE;
	}

	static gboolean
	crm_reap_dead_member(gpointer key, gpointer value, gpointer user_data)
	{
	crm_node_t *node = value;
	crm_node_t *search = user_data;

	if (search == NULL) {
	return FALSE;

	} else if (search->id && node->id != search->id) {
	return FALSE;

	} else if (search->id == 0 && safe_str_neq(node->uname, search->uname)) {
	return FALSE;

	} else if (crm_is_peer_active(value) == FALSE) {
	crm_notice("Removing %s/%u from the membership list", node->uname, node->id);
	return TRUE;
	}
	return FALSE;
	}

	/*!
	* \brief Remove all peer cache entries matching a node ID and/or uname
	*
	* \param[in] id ID of node to remove (or 0 to ignore)
	* \param[in] name Uname of node to remove (or NULL to ignore)
	*
	* \return Number of cache entries removed
	*/
	guint
	reap_crm_member(uint32_t id, const char *name)
	{
	int matches = 0;
	crm_node_t search;

	if (crm_peer_cache == NULL) {
	crm_trace("Nothing to do, cache not initialized");
	return 0;
	}

	search.id = id;
	search.uname = name ? strdup(name) : NULL;
	matches = g_hash_table_foreach_remove(crm_peer_cache, crm_reap_dead_member, &search);
	if(matches) {
	crm_notice("Purged %d peers with id=%u and/or uname=%s from the membership cache",
	matches, search.id, search.uname);

	} else {
	crm_info("No peers with id=%u and/or uname=%s exist", id, name);
	}

	free(search.uname);
	return matches;
	}

	static void
	crm_count_peer(gpointer key, gpointer value, gpointer user_data)
	{
	guint *count = user_data;
	crm_node_t *node = value;

	if (crm_is_peer_active(node)) {
	count = count + 1;
	}
	}

	guint
	crm_active_peers(void)
	{
	guint count = 0;

	if (crm_peer_cache) {
	g_hash_table_foreach(crm_peer_cache, crm_count_peer, &count);
	}
	return count;
	}

	static void
	destroy_crm_node(gpointer data)
	{
	crm_node_t *node = data;

	crm_trace("Destroying entry for node %u: %s", node->id, node->uname);

	free(node->addr);
	free(node->uname);
	free(node->state);
	free(node->uuid);
	free(node->expected);
	free(node);
	}

	void
	crm_peer_init(void)
	{
	if (crm_peer_cache == NULL) {
	crm_peer_cache = g_hash_table_new_full(crm_strcase_hash, crm_strcase_equal, free, destroy_crm_node);
	}

	if (crm_remote_peer_cache == NULL) {
	crm_remote_peer_cache = g_hash_table_new_full(crm_strcase_hash, crm_strcase_equal, NULL, destroy_crm_node);
	}
	}

	void
	crm_peer_destroy(void)
	{
	if (crm_peer_cache != NULL) {
	crm_trace("Destroying peer cache with %d members", g_hash_table_size(crm_peer_cache));
	g_hash_table_destroy(crm_peer_cache);
	crm_peer_cache = NULL;
	}

	if (crm_remote_peer_cache != NULL) {
	crm_trace("Destroying remote peer cache with %d members", g_hash_table_size(crm_remote_peer_cache));
	g_hash_table_destroy(crm_remote_peer_cache);
	crm_remote_peer_cache = NULL;
	}
	}

	void (crm_status_callback) (enum crm_status_type, crm_node_t , const void *) = NULL;

	/*!
	* \brief Set a client function that will be called after peer status changes
	*
	* \param[in] dispatch Pointer to function to use as callback
	*
	* \note Previously, client callbacks were responsible for peer cache
	* management. This is no longer the case, and client callbacks should do
	* only client-specific handling. Callbacks MUST NOT add or remove entries
	* in the peer caches.
	*/
	void
	crm_set_status_callback(void (dispatch) (enum crm_status_type, crm_node_t , const void *))
	{
	crm_status_callback = dispatch;
	}

	/*!
	* \brief Tell the library whether to automatically reap lost nodes
	*
	* If TRUE (the default), calling crm_update_peer_proc() will also update the
	* peer state to CRM_NODE_MEMBER or CRM_NODE_LOST, and crm_update_peer_state()
	* will reap peers whose state changes to anything other than CRM_NODE_MEMBER.
	* Callers should leave this enabled unless they plan to manage the cache
	* separately on their own.
	*
	* \param[in] autoreap TRUE to enable automatic reaping, FALSE to disable
	*/
	void
	crm_set_autoreap(gboolean autoreap)
	{
	crm_autoreap = autoreap;
	}

	static void crm_dump_peer_hash(int level, const char *caller)
	{
	GHashTableIter iter;
	const char *id = NULL;
	crm_node_t *node = NULL;

	g_hash_table_iter_init(&iter, crm_peer_cache);
	while (g_hash_table_iter_next(&iter, (gpointer ) &id, (gpointer ) &node)) {
	do_crm_log(level, "%s: Node %u/%s = %p - %s", caller, node->id, node->uname, node, id);
	}
	}

	static gboolean crm_hash_find_by_data(gpointer key, gpointer value, gpointer user_data)
	{
	if(value == user_data) {
	return TRUE;
	}
	return FALSE;
	}

	crm_node_t *
	crm_find_peer_full(unsigned int id, const char *uname, int flags)
	{
	crm_node_t *node = NULL;

	CRM_ASSERT(id > 0 \|\| uname != NULL);

	crm_peer_init();

	if (flags & CRM_GET_PEER_REMOTE) {
	node = g_hash_table_lookup(crm_remote_peer_cache, uname);
	}

	if (node == NULL && (flags & CRM_GET_PEER_CLUSTER)) {
	node = crm_find_peer(id, uname);
	}
	return node;
	}

	crm_node_t *
	crm_get_peer_full(unsigned int id, const char *uname, int flags)
	{
	crm_node_t *node = NULL;

	CRM_ASSERT(id > 0 \|\| uname != NULL);

	crm_peer_init();

	if (flags & CRM_GET_PEER_REMOTE) {
	node = g_hash_table_lookup(crm_remote_peer_cache, uname);
	}

	if (node == NULL && (flags & CRM_GET_PEER_CLUSTER)) {
	node = crm_get_peer(id, uname);
	}
	return node;
	}

	crm_node_t *
	crm_find_peer(unsigned int id, const char *uname)
	{
	GHashTableIter iter;
	crm_node_t *node = NULL;
	crm_node_t *by_id = NULL;
	crm_node_t *by_name = NULL;

	CRM_ASSERT(id > 0 \|\| uname != NULL);

	crm_peer_init();

	if (uname != NULL) {
	g_hash_table_iter_init(&iter, crm_peer_cache);
	while (g_hash_table_iter_next(&iter, NULL, (gpointer *) &node)) {
	if(node->uname && strcasecmp(node->uname, uname) == 0) {
	crm_trace("Name match: %s = %p", node->uname, node);
	by_name = node;
	break;
	}
	}
	}

	if (id > 0) {
	g_hash_table_iter_init(&iter, crm_peer_cache);
	while (g_hash_table_iter_next(&iter, NULL, (gpointer *) &node)) {
	if(node->id == id) {
	crm_trace("ID match: %u = %p", node->id, node);
	by_id = node;
	break;
	}
	}
	}

	node = by_id; /* Good default */
	if(by_id == by_name) {
	/* Nothing to do if they match (both NULL counts) */
	crm_trace("Consistent: %p for %u/%s", by_id, id, uname);

	} else if(by_id == NULL && by_name) {
	crm_trace("Only one: %p for %u/%s", by_name, id, uname);

	if(id && by_name->id) {
	crm_dump_peer_hash(LOG_WARNING, __FUNCTION__);
	crm_crit("Node %u and %u share the same name '%s'",
	id, by_name->id, uname);
	node = NULL; /* Create a new one */

	} else {
	node = by_name;
	}

	} else if(by_name == NULL && by_id) {
	crm_trace("Only one: %p for %u/%s", by_id, id, uname);

	if(uname && by_id->uname) {
	crm_dump_peer_hash(LOG_WARNING, __FUNCTION__);
	crm_crit("Node '%s' and '%s' share the same cluster nodeid %u: assuming '%s' is correct",
	uname, by_id->uname, id, uname);
	}

	} else if(uname && by_id->uname) {
	if(safe_str_eq(uname, by_id->uname)) {
	crm_notice("Node '%s' has changed its ID from %u to %u", by_id->uname, by_name->id, by_id->id);
	g_hash_table_foreach_remove(crm_peer_cache, crm_hash_find_by_data, by_name);

	} else {
	crm_warn("Node '%s' and '%s' share the same cluster nodeid: %u %s", by_id->uname, by_name->uname, id, uname);
	crm_dump_peer_hash(LOG_INFO, __FUNCTION__);
	crm_abort(__FILE__, __FUNCTION__, __LINE__, "member weirdness", TRUE, TRUE);
	}

	} else if(id && by_name->id) {
	crm_warn("Node %u and %u share the same name: '%s'", by_id->id, by_name->id, uname);

	} else {
	/* Simple merge */

	/* Only corosync based clusters use nodeid's
	*
	* The functions that call crm_update_peer_state() only know nodeid
	* so 'by_id' is authorative when merging
	*
	* Same for crm_update_peer_proc()
	*/
	crm_dump_peer_hash(LOG_DEBUG, __FUNCTION__);

	crm_info("Merging %p into %p", by_name, by_id);
	g_hash_table_foreach_remove(crm_peer_cache, crm_hash_find_by_data, by_name);
	}

	return node;
	}

	#if SUPPORT_COROSYNC
	static guint
	crm_remove_conflicting_peer(crm_node_t *node)
	{
	int matches = 0;
	GHashTableIter iter;
	crm_node_t *existing_node = NULL;

	if (node->id == 0 \|\| node->uname == NULL) {
	return 0;
	}

	# if !SUPPORT_PLUGIN
	if (corosync_cmap_has_config("nodelist") != 0) {
	return 0;
	}
	# endif

	g_hash_table_iter_init(&iter, crm_peer_cache);
	while (g_hash_table_iter_next(&iter, NULL, (gpointer *) &existing_node)) {
	if (existing_node->id > 0
	&& existing_node->id != node->id
	&& existing_node->uname != NULL
	&& strcasecmp(existing_node->uname, node->uname) == 0) {

	if (crm_is_peer_active(existing_node)) {
	continue;
	}

	crm_warn("Removing cached offline node %u/%s which has conflicting uname with %u",
	existing_node->id, existing_node->uname, node->id);

	g_hash_table_iter_remove(&iter);
	matches++;
	}
	}

	return matches;
	}
	#endif

	/* coverity[-alloc] Memory is referenced in one or both hashtables */
	crm_node_t *
	crm_get_peer(unsigned int id, const char *uname)
	{
	crm_node_t *node = NULL;
	char *uname_lookup = NULL;

	CRM_ASSERT(id > 0 \|\| uname != NULL);

	crm_peer_init();

	node = crm_find_peer(id, uname);

	/* if uname wasn't provided, and find_peer did not turn up a uname based on id.
	* we need to do a lookup of the node name using the id in the cluster membership. */
	if ((node == NULL \|\| node->uname == NULL) && (uname == NULL)) {
	uname_lookup = get_node_name(id);
	}

	if (uname_lookup) {
	uname = uname_lookup;
	crm_trace("Inferred a name of '%s' for node %u", uname, id);

	/* try to turn up the node one more time now that we know the uname. */
	if (node == NULL) {
	node = crm_find_peer(id, uname);
	}
	}


	if (node == NULL) {
	char *uniqueid = crm_generate_uuid();

	node = calloc(1, sizeof(crm_node_t));
	CRM_ASSERT(node);

	crm_info("Created entry %s/%p for node %s/%u (%d total)",
	uniqueid, node, uname, id, 1 + g_hash_table_size(crm_peer_cache));
	g_hash_table_replace(crm_peer_cache, uniqueid, node);
	}

	if(id > 0 && uname && (node->id == 0 \|\| node->uname == NULL)) {
	crm_info("Node %u is now known as %s", id, uname);
	}

	if(id > 0 && node->id == 0) {
	node->id = id;
	}

	- if(uname && node->uname == NULL) {
	- int lpc, len = strlen(uname);
	-
	- for (lpc = 0; lpc < len; lpc++) {
	- if (uname[lpc] >= 'A' && uname[lpc] <= 'Z') {
	- crm_warn("Node names with capitals are discouraged, consider changing '%s' to something else",
	- uname);
	- break;
	- }
	- }
	-
	- node->uname = strdup(uname);
	- if (crm_status_callback) {
	- crm_status_callback(crm_status_uname, node, NULL);
	- }
	-
	-#if SUPPORT_COROSYNC
	- if (is_openais_cluster()) {
	- crm_remove_conflicting_peer(node);
	- }
	-#endif
	+ if (uname && (node->uname == NULL)) {
	+ crm_update_peer_uname(node, uname);
	}

	if(node->uuid == NULL) {
	const char *uuid = crm_peer_uuid(node);

	if (uuid) {
	crm_info("Node %u has uuid %s", id, uuid);

	} else {
	crm_info("Cannot obtain a UUID for node %u/%s", id, node->uname);
	}
	}

	free(uname_lookup);

	return node;
	}

	/*!
	* \internal
	* \brief Update all of a node's information (process list, state, etc.)
	*
	* \param[in] source Caller's function name (for log messages)
	*
	* \return NULL if node was reaped from peer caches, pointer to node otherwise
	*
	* \note This function should not be called within a peer cache iteration,
	* otherwise reaping could invalidate the iterator.
	*/
	crm_node_t *
	crm_update_peer(const char *source, unsigned int id, uint64_t born, uint64_t seen, int32_t votes,
	uint32_t children, const char uuid, const char uname, const char *addr,
	const char *state)
	{
	#if SUPPORT_PLUGIN
	gboolean addr_changed = FALSE;
	gboolean votes_changed = FALSE;
	#endif
	crm_node_t *node = NULL;

	id = get_corosync_id(id, uuid);
	node = crm_get_peer(id, uname);

	CRM_ASSERT(node != NULL);

	if (node->uuid == NULL) {
	if (is_openais_cluster()) {
	/* Yes, overrule whatever was passed in */
	crm_peer_uuid(node);

	} else if (uuid != NULL) {
	node->uuid = strdup(uuid);
	}
	}

	if (children > 0) {
	if (crm_update_peer_proc(source, node, children, state) == NULL) {
	return NULL;
	}
	}

	if (state != NULL) {
	if (crm_update_peer_state(source, node, state, seen) == NULL) {
	return NULL;
	}
	}
	#if SUPPORT_HEARTBEAT
	if (born != 0) {
	node->born = born;
	}
	#endif

	#if SUPPORT_PLUGIN
	/* These were only used by the plugin */
	if (born != 0) {
	node->born = born;
	}

	if (votes > 0 && node->votes != votes) {
	votes_changed = TRUE;
	node->votes = votes;
	}

	if (addr != NULL) {
	if (node->addr == NULL \|\| crm_str_eq(node->addr, addr, FALSE) == FALSE) {
	addr_changed = TRUE;
	free(node->addr);
	node->addr = strdup(addr);
	}
	}
	if (addr_changed \|\| votes_changed) {
	crm_info("%s: Node %s: id=%u state=%s addr=%s%s votes=%d%s born=" U64T " seen=" U64T
	" proc=%.32x", source, node->uname, node->id, node->state,
	node->addr, addr_changed ? " (new)" : "", node->votes,
	votes_changed ? " (new)" : "", node->born, node->last_seen, node->processes);
	}
	#endif

	return node;
	}

	+/*!
	+ * \internal
	+ * \brief Update a node's uname
	+ *
	+ * \param[in] node Node object to update
	+ * \param[in] uname New name to set
	+ *
	+ * \note This function should not be called within a peer cache iteration,
	+ * because in some cases it can remove conflicting cache entries,
	+ * which would invalidate the iterator.
	+ */
	+void
	+crm_update_peer_uname(crm_node_t node, const char uname)
	+{
	+ int i, len = strlen(uname);
	+
	+ for (i = 0; i < len; i++) {
	+ if (uname[i] >= 'A' && uname[i] <= 'Z') {
	+ crm_warn("Node names with capitals are discouraged, consider changing '%s'",
	+ uname);
	+ break;
	+ }
	+ }
	+
	+ free(node->uname);
	+ node->uname = strdup(uname);
	+ if (crm_status_callback) {
	+ crm_status_callback(crm_status_uname, node, NULL);
	+ }
	+
	+#if SUPPORT_COROSYNC
	+ if (is_openais_cluster() && !is_set(node->flags, crm_remote_node)) {
	+ crm_remove_conflicting_peer(node);
	+ }
	+#endif
	+}
	+
	/*!
	* \internal
	* \brief Update a node's process information (and potentially state)
	*
	* \param[in] source Caller's function name (for log messages)
	* \param[in] node Node object to update
	* \param[in] flag Bitmask of new process information
	* \param[in] status node status (online, offline, etc.)
	*
	* \return NULL if any node was reaped from peer caches, value of node otherwise
	*
	* \note If this function returns NULL, the supplied node object was likely
	* freed and should not be used again. This function should not be
	* called within a cache iteration if reaping is possible, otherwise
	* reaping could invalidate the iterator.
	*/
	crm_node_t *
	crm_update_peer_proc(const char source, crm_node_t node, uint32_t flag, const char *status)
	{
	uint32_t last = 0;
	gboolean changed = FALSE;

	CRM_CHECK(node != NULL, crm_err("%s: Could not set %s to %s for NULL",
	source, peer2text(flag), status); return NULL);

	/* Pacemaker doesn't spawn processes on remote nodes */
	if (is_set(node->flags, crm_remote_node)) {
	return node;
	}

	last = node->processes;
	if (status == NULL) {
	node->processes = flag;
	if (node->processes != last) {
	changed = TRUE;
	}

	} else if (safe_str_eq(status, ONLINESTATUS)) {
	if ((node->processes & flag) != flag) {
	set_bit(node->processes, flag);
	changed = TRUE;
	}
	#if SUPPORT_PLUGIN
	} else if (safe_str_eq(status, CRM_NODE_MEMBER)) {
	if (flag > 0 && node->processes != flag) {
	node->processes = flag;
	changed = TRUE;
	}
	#endif

	} else if (node->processes & flag) {
	clear_bit(node->processes, flag);
	changed = TRUE;
	}

	if (changed) {
	if (status == NULL && flag <= crm_proc_none) {
	crm_info("%s: Node %s[%u] - all processes are now offline", source, node->uname,
	node->id);
	} else {
	crm_info("%s: Node %s[%u] - %s is now %s", source, node->uname, node->id,
	peer2text(flag), status);
	}

	/* Call the client callback first, then update the peer state,
	* in case the node will be reaped
	*/
	if (crm_status_callback) {
	crm_status_callback(crm_status_processes, node, &last);
	}

	/* The client callback shouldn't touch the peer caches,
	* but as a safety net, bail if the peer cache was destroyed.
	*/
	if (crm_peer_cache == NULL) {
	return NULL;
	}

	if (crm_autoreap) {
	node = crm_update_peer_state(__FUNCTION__, node,
	is_set(node->processes, crm_get_cluster_proc())?
	CRM_NODE_MEMBER : CRM_NODE_LOST, 0);
	}
	} else {
	crm_trace("%s: Node %s[%u] - %s is unchanged (%s)", source, node->uname, node->id,
	peer2text(flag), status);
	}
	return node;
	}

	void
	crm_update_peer_expected(const char source, crm_node_t node, const char *expected)
	{
	char *last = NULL;
	gboolean changed = FALSE;

	CRM_CHECK(node != NULL, crm_err("%s: Could not set 'expected' to %s", source, expected);
	return);

	/* Remote nodes don't participate in joins */
	if (is_set(node->flags, crm_remote_node)) {
	return;
	}

	last = node->expected;
	if (expected != NULL && safe_str_neq(node->expected, expected)) {
	node->expected = strdup(expected);
	changed = TRUE;
	}

	if (changed) {
	crm_info("%s: Node %s[%u] - expected state is now %s (was %s)", source, node->uname, node->id,
	expected, last);
	free(last);
	} else {
	crm_trace("%s: Node %s[%u] - expected state is unchanged (%s)", source, node->uname,
	node->id, expected);
	}
	}

	/*!
	* \internal
	* \brief Update a node's state and membership information
	*
	* \param[in] source Caller's function name (for log messages)
	* \param[in] node Node object to update
	* \param[in] state Node's new state
	* \param[in] membership Node's new membership ID
	* \param[in] iter If not NULL, pointer to node's peer cache iterator
	*
	* \return NULL if any node was reaped, value of node otherwise
	*
	* \note If this function returns NULL, the supplied node object was likely
	* freed and should not be used again. This function may be called from
	* within a peer cache iteration if the iterator is supplied.
	*/
	static crm_node_t *
	crm_update_peer_state_iter(const char source, crm_node_t node, const char state, int membership, GHashTableIter iter)
	{
	gboolean is_member;

	CRM_CHECK(node != NULL, crm_err("%s: Could not set 'state' to %s", source, state);
	return NULL);

	is_member = safe_str_eq(state, CRM_NODE_MEMBER);
	if (membership && is_member) {
	node->last_seen = membership;
	}

	if (state && safe_str_neq(node->state, state)) {
	char *last = node->state;
	enum crm_status_type status_type = is_set(node->flags, crm_remote_node)?
	crm_status_rstate : crm_status_nstate;

	node->state = strdup(state);
	crm_notice("%s: Node %s[%u] - state is now %s (was %s)",
	source, node->uname, node->id, state, last);
	if (crm_status_callback) {
	crm_status_callback(status_type, node, last);
	}
	free(last);

	if (crm_autoreap && !is_member && !is_set(node->flags, crm_remote_node)) {
	/* We only autoreap from the peer cache, not the remote peer cache,
	* because the latter should be managed only by
	* crm_remote_peer_cache_refresh().
	*/
	if(iter) {
	crm_notice("Purged 1 peer with id=%u and/or uname=%s from the membership cache", node->id, node->uname);
	g_hash_table_iter_remove(iter);

	} else {
	reap_crm_member(node->id, node->uname);
	}
	node = NULL;
	}

	} else {
	crm_trace("%s: Node %s[%u] - state is unchanged (%s)", source, node->uname, node->id,
	state);
	}
	return node;
	}

	/*!
	* \brief Update a node's state and membership information
	*
	* \param[in] source Caller's function name (for log messages)
	* \param[in] node Node object to update
	* \param[in] state Node's new state
	* \param[in] membership Node's new membership ID
	*
	* \return NULL if any node was reaped, value of node otherwise
	*
	* \note If this function returns NULL, the supplied node object was likely
	* freed and should not be used again. This function should not be
	* called within a cache iteration if reaping is possible,
	* otherwise reaping could invalidate the iterator.
	*/
	crm_node_t *
	crm_update_peer_state(const char source, crm_node_t node, const char *state, int membership)
	{
	return crm_update_peer_state_iter(source, node, state, membership, NULL);
	}

	/*!
	* \internal
	* \brief Reap all nodes from cache whose membership information does not match
	*
	* \param[in] membership Membership ID of nodes to keep
	*/
	void
	crm_reap_unseen_nodes(uint64_t membership)
	{
	GHashTableIter iter;
	crm_node_t *node = NULL;

	crm_trace("Reaping unseen nodes...");
	g_hash_table_iter_init(&iter, crm_peer_cache);
	while (g_hash_table_iter_next(&iter, NULL, (gpointer *)&node)) {
	if (node->last_seen != membership) {
	if (node->state) {
	/*
	* Calling crm_update_peer_state_iter() allows us to
	* remove the node from crm_peer_cache without
	* invalidating our iterator
	*/
	crm_update_peer_state_iter(__FUNCTION__, node, CRM_NODE_LOST, membership, &iter);

	} else {
	crm_info("State of node %s[%u] is still unknown",
	node->uname, node->id);
	}
	}
	}
	}

	int
	crm_terminate_member(int nodeid, const char uname, void unused)
	{
	/* Always use the synchronous, non-mainloop version */
	return stonith_api_kick(nodeid, uname, 120, TRUE);
	}

	int
	crm_terminate_member_no_mainloop(int nodeid, const char uname, int connection)
	{
	return stonith_api_kick(nodeid, uname, 120, TRUE);
	}

File Metadata

Mime Type: text/x-diff
Expires: Thu, Jul 10, 1:34 AM (22 h, 35 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 2009522
Default Alt Text: (43 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions