No OneTemporary
Actions

Size

52 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/crmd/te_callbacks.c b/crmd/te_callbacks.c
	index c2b0c0d511..0a8de958ce 100644
	--- a/crmd/te_callbacks.c
	+++ b/crmd/te_callbacks.c
	@@ -1,914 +1,918 @@
	/*
	* 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
	*/

	#include <crm_internal.h>

	#include <sys/stat.h>

	#include <crm/crm.h>
	#include <crm/common/xml.h>
	#include <crm/msg_xml.h>

	#include <tengine.h>
	#include <te_callbacks.h>
	#include <crmd_fsa.h>

	#include <crm/cluster.h> /* For ONLINESTATUS etc */

	void te_update_confirm(const char event, xmlNode msg);

	extern char *te_uuid;
	gboolean shuttingdown = FALSE;
	crm_graph_t *transition_graph;
	crm_trigger_t *transition_trigger = NULL;

	static unsigned long int stonith_max_attempts = 10;

	/* #define rsc_op_template "//"XML_TAG_DIFF_ADDED"//"XML_TAG_CIB"//"XML_CIB_TAG_STATE"[@uname='%s']"//"XML_LRM_TAG_RSC_OP"[@id='%s]" */
	#define rsc_op_template "//"XML_TAG_DIFF_ADDED"//"XML_TAG_CIB"//"XML_LRM_TAG_RSC_OP"[@id='%s']"

	static const char *
	get_node_id(xmlNode * rsc_op)
	{
	xmlNode *node = rsc_op;

	while (node != NULL && safe_str_neq(XML_CIB_TAG_STATE, TYPE(node))) {
	node = node->parent;
	}

	CRM_CHECK(node != NULL, return NULL);
	return ID(node);
	}

	void
	update_stonith_max_attempts(const char* value)
	{
	if (safe_str_eq(value, INFINITY_S)) {
	stonith_max_attempts = node_score_infinity;
	}
	else {
	stonith_max_attempts = crm_int_helper(value, NULL);
	}
	}
	static void
	te_legacy_update_diff(const char event, xmlNode diff)
	{
	int lpc, max;
	xmlXPathObject *xpathObj = NULL;

	CRM_CHECK(diff != NULL, return);

	xml_log_patchset(LOG_TRACE, __FUNCTION__, diff);
	if (cib_config_changed(NULL, NULL, &diff)) {
	abort_transition(INFINITY, tg_restart, "Non-status change", diff);
	goto bail; /* configuration changed */
	}

	/* Tickets Attributes - Added/Updated */
	xpathObj =
	xpath_search(diff,
	"//" F_CIB_UPDATE_RESULT "//" XML_TAG_DIFF_ADDED "//" XML_CIB_TAG_TICKETS);
	if (numXpathResults(xpathObj) > 0) {
	xmlNode *aborted = getXpathResult(xpathObj, 0);

	abort_transition(INFINITY, tg_restart, "Ticket attribute: update", aborted);
	goto bail;

	}
	freeXpathObject(xpathObj);

	/* Tickets Attributes - Removed */
	xpathObj =
	xpath_search(diff,
	"//" F_CIB_UPDATE_RESULT "//" XML_TAG_DIFF_REMOVED "//" XML_CIB_TAG_TICKETS);
	if (numXpathResults(xpathObj) > 0) {
	xmlNode *aborted = getXpathResult(xpathObj, 0);

	abort_transition(INFINITY, tg_restart, "Ticket attribute: removal", aborted);
	goto bail;
	}
	freeXpathObject(xpathObj);

	/* Transient Attributes - Added/Updated */
	xpathObj =
	xpath_search(diff,
	"//" F_CIB_UPDATE_RESULT "//" XML_TAG_DIFF_ADDED "//"
	XML_TAG_TRANSIENT_NODEATTRS "//" XML_CIB_TAG_NVPAIR);
	max = numXpathResults(xpathObj);

	for (lpc = 0; lpc < max; lpc++) {
	xmlNode *attr = getXpathResult(xpathObj, lpc);
	const char *name = crm_element_value(attr, XML_NVPAIR_ATTR_NAME);
	const char *value = NULL;

	if (safe_str_eq(CRM_OP_PROBED, name)) {
	value = crm_element_value(attr, XML_NVPAIR_ATTR_VALUE);
	}

	if (crm_is_true(value) == FALSE) {
	abort_transition(INFINITY, tg_restart, "Transient attribute: update", attr);
	crm_log_xml_trace(attr, "Abort");
	goto bail;
	}
	}

	freeXpathObject(xpathObj);

	/* Transient Attributes - Removed */
	xpathObj =
	xpath_search(diff,
	"//" F_CIB_UPDATE_RESULT "//" XML_TAG_DIFF_REMOVED "//"
	XML_TAG_TRANSIENT_NODEATTRS);
	if (numXpathResults(xpathObj) > 0) {
	xmlNode *aborted = getXpathResult(xpathObj, 0);

	abort_transition(INFINITY, tg_restart, "Transient attribute: removal", aborted);
	goto bail;

	}
	freeXpathObject(xpathObj);

	/*
	* Check for and fast-track the processing of LRM refreshes
	* In large clusters this can result in _huge_ speedups
	*
	* Unfortunately we can only do so when there are no pending actions
	* Otherwise we could miss updates we're waiting for and stall
	*
	*/
	xpathObj = NULL;
	if (transition_graph->pending == 0) {
	xpathObj =
	xpath_search(diff,
	"//" F_CIB_UPDATE_RESULT "//" XML_TAG_DIFF_ADDED "//"
	XML_LRM_TAG_RESOURCE);
	}

	max = numXpathResults(xpathObj);
	if (max > 1) {
	/* Updates by, or in response to, TE actions will never contain updates
	* for more than one resource at a time
	*/
	crm_debug("Detected LRM refresh - %d resources updated: Skipping all resource events", max);
	crm_log_xml_trace(diff, "lrm-refresh");
	abort_transition(INFINITY, tg_restart, "LRM Refresh", NULL);
	goto bail;
	}
	freeXpathObject(xpathObj);

	/* Process operation updates */
	xpathObj =
	xpath_search(diff,
	"//" F_CIB_UPDATE_RESULT "//" XML_TAG_DIFF_ADDED "//" XML_LRM_TAG_RSC_OP);
	if (numXpathResults(xpathObj)) {
	/*
	<status>
	<node_state id="node1" state=CRMD_JOINSTATE_MEMBER exp_state="active">
	<lrm>
	<lrm_resources>
	<rsc_state id="" rsc_id="rsc4" node_id="node1" rsc_state="stopped"/>
	*/
	int lpc = 0, max = numXpathResults(xpathObj);

	for (lpc = 0; lpc < max; lpc++) {
	xmlNode *rsc_op = getXpathResult(xpathObj, lpc);
	const char *node = get_node_id(rsc_op);

	process_graph_event(rsc_op, node);
	}
	}
	freeXpathObject(xpathObj);

	/* Detect deleted (as opposed to replaced or added) actions - eg. crm_resource -C */
	xpathObj = xpath_search(diff, "//" XML_TAG_DIFF_REMOVED "//" XML_LRM_TAG_RSC_OP);
	max = numXpathResults(xpathObj);
	for (lpc = 0; lpc < max; lpc++) {
	int path_max = 0;
	const char *op_id = NULL;
	char *rsc_op_xpath = NULL;
	xmlXPathObject *op_match = NULL;
	xmlNode *match = getXpathResult(xpathObj, lpc);

	CRM_LOG_ASSERT(match != NULL);
	if(match == NULL) { continue; };

	op_id = ID(match);

	path_max = strlen(rsc_op_template) + strlen(op_id) + 1;
	rsc_op_xpath = calloc(1, path_max);
	snprintf(rsc_op_xpath, path_max, rsc_op_template, op_id);

	op_match = xpath_search(diff, rsc_op_xpath);
	if (numXpathResults(op_match) == 0) {
	/* Prevent false positives by matching cancelations too */
	const char *node = get_node_id(match);
	crm_action_t *cancelled = get_cancel_action(op_id, node);

	if (cancelled == NULL) {
	crm_debug("No match for deleted action %s (%s on %s)", rsc_op_xpath, op_id,
	node);
	abort_transition(INFINITY, tg_restart, "Resource op removal", match);
	freeXpathObject(op_match);
	free(rsc_op_xpath);
	goto bail;

	} else {
	crm_debug("Deleted lrm_rsc_op %s on %s was for graph event %d",
	op_id, node, cancelled->id);
	}
	}

	freeXpathObject(op_match);
	free(rsc_op_xpath);
	}

	bail:
	freeXpathObject(xpathObj);
	}

	static void process_resource_updates(
	const char node, xmlNode xml, xmlNode change, const char op, const char *xpath)
	{
	xmlNode *cIter = NULL;
	xmlNode *rsc = NULL;
	xmlNode *rsc_op = NULL;
	int num_resources = 0;

	if(xml == NULL) {
	return;

	} else if(strcmp((const char*)xml->name, XML_CIB_TAG_LRM) == 0) {
	xml = first_named_child(xml, XML_LRM_TAG_RESOURCES);
	crm_trace("Got %p in %s", xml, XML_CIB_TAG_LRM);
	}

	CRM_ASSERT(strcmp((const char*)xml->name, XML_LRM_TAG_RESOURCES) == 0);

	for(cIter = xml->children; cIter; cIter = cIter->next) {
	num_resources++;
	}

	if(num_resources > 1) {
	/*
	* Check for and fast-track the processing of LRM refreshes
	* In large clusters this can result in _huge_ speedups
	*
	* Unfortunately we can only do so when there are no pending actions
	* Otherwise we could miss updates we're waiting for and stall
	*
	*/

	crm_debug("Detected LRM refresh - %d resources updated", num_resources);
	crm_log_xml_trace(change, "lrm-refresh");
	abort_transition(INFINITY, tg_restart, "LRM Refresh", NULL);
	return;
	}

	for (rsc = __xml_first_child(xml); rsc != NULL; rsc = __xml_next(rsc)) {
	crm_trace("Processing %s", ID(rsc));
	for (rsc_op = __xml_first_child(rsc); rsc_op != NULL; rsc_op = __xml_next(rsc_op)) {
	crm_trace("Processing %s", ID(rsc_op));
	process_graph_event(rsc_op, node);
	}
	}
	}

	#define NODE_PATT "/lrm[@id="
	static char get_node_from_xpath(const char xpath)
	{
	char *nodeid = NULL;
	char *tmp = strstr(xpath, NODE_PATT);

	if(tmp) {
	tmp += strlen(NODE_PATT);
	tmp += 1;

	nodeid = strdup(tmp);
	tmp = strstr(nodeid, "\'");
	CRM_ASSERT(tmp);
	tmp[0] = 0;
	}
	return nodeid;
	}

	static char extract_node_uuid(const char xpath)
	{
	char *mutable_path = strdup(xpath);
	char *node_uuid = NULL;
	char *search = NULL;
	char *match = NULL;

	match = strstr(mutable_path, "node_state[@id=\'");
	if (match == NULL) {
	free(mutable_path);
	return NULL;
	}
	match += strlen("node_state[@id=\'");

	search = strchr(match, '\'');
	if (search == NULL) {
	free(mutable_path);
	return NULL;
	}
	search[0] = 0;

	node_uuid = strdup(match);
	free(mutable_path);
	return node_uuid;
	}

	static void
	abort_unless_down(const char xpath, const char op, xmlNode *change,
	const char *reason)
	{
	char *node_uuid = NULL;
	crm_action_t *down = NULL;

	if(safe_str_neq(op, "delete")) {
	abort_transition(INFINITY, tg_restart, reason, change);
	return;
	}

	node_uuid = extract_node_uuid(xpath);
	if(node_uuid == NULL) {
	crm_err("Could not extract node ID from %s", xpath);
	abort_transition(INFINITY, tg_restart, reason, change);
	return;
	}

	down = match_down_event(node_uuid, TRUE);
	if(down == NULL \|\| down->executed == false) {
	crm_trace("Not expecting %s to be down (%s)", node_uuid, xpath);
	abort_transition(INFINITY, tg_restart, reason, change);
	} else {
	crm_trace("Expecting changes to %s (%s)", node_uuid, xpath);
	}
	free(node_uuid);
	}

	void
	te_update_diff(const char event, xmlNode msg)
	{
	int rc = -EINVAL;
	int format = 1;
	xmlNode *change = NULL;
	const char *op = NULL;

	xmlNode *diff = NULL;

	int p_add[] = { 0, 0, 0 };
	int p_del[] = { 0, 0, 0 };

	CRM_CHECK(msg != NULL, return);
	crm_element_value_int(msg, F_CIB_RC, &rc);

	if (transition_graph == NULL) {
	crm_trace("No graph");
	return;

	} else if (rc < pcmk_ok) {
	crm_trace("Filter rc=%d (%s)", rc, pcmk_strerror(rc));
	return;

	} else if (transition_graph->complete == TRUE
	&& fsa_state != S_IDLE
	&& fsa_state != S_TRANSITION_ENGINE && fsa_state != S_POLICY_ENGINE) {
	crm_trace("Filter state=%s, complete=%d", fsa_state2string(fsa_state),
	transition_graph->complete);
	return;
	}

	op = crm_element_value(msg, F_CIB_OPERATION);
	diff = get_message_xml(msg, F_CIB_UPDATE_RESULT);

	xml_patch_versions(diff, p_add, p_del);
	crm_debug("Processing (%s) diff: %d.%d.%d -> %d.%d.%d (%s)", op,
	p_del[0], p_del[1], p_del[2], p_add[0], p_add[1], p_add[2],
	fsa_state2string(fsa_state));

	crm_element_value_int(diff, "format", &format);
	switch(format) {
	case 1:
	te_legacy_update_diff(event, diff);
	return;
	case 2:
	/* Cool, we know what to do here */
	crm_log_xml_trace(diff, "Patch:Raw");
	break;
	default:
	crm_warn("Unknown patch format: %d", format);
	return;
	}

	for (change = __xml_first_child(diff); change != NULL; change = __xml_next(change)) {
	const char *name = NULL;
	const char *op = crm_element_value(change, XML_DIFF_OP);
	const char *xpath = crm_element_value(change, XML_DIFF_PATH);
	xmlNode *match = NULL;
	const char *node = NULL;

	if(op == NULL) {
	continue;

	} else if(strcmp(op, "create") == 0) {
	match = change->children;

	} else if(strcmp(op, "move") == 0) {
	continue;

	} else if(strcmp(op, "modify") == 0) {
	match = first_named_child(change, XML_DIFF_RESULT);
	if(match) {
	match = match->children;
	}
	}

	if(match) {
	if (match->type == XML_COMMENT_NODE) {
	crm_trace("Ignoring %s operation for comment at %s", op, xpath);
	continue;
	}
	name = (const char *)match->name;
	}

	crm_trace("Handling %s operation for %s%s%s",
	op, (xpath? xpath : "CIB"),
	(name? " matched by " : ""), (name? name : ""));
	if(xpath == NULL) {
	/* Version field, ignore */

	} else if(strstr(xpath, "/cib/configuration")) {
	abort_transition(INFINITY, tg_restart, "Configuration change", change);
	break; /* Won't be packaged with any resource operations we may be waiting for */

	} else if(strstr(xpath, "/"XML_CIB_TAG_TICKETS) \|\| safe_str_eq(name, XML_CIB_TAG_TICKETS)) {
	abort_transition(INFINITY, tg_restart, "Ticket attribute change", change);
	break; /* Won't be packaged with any resource operations we may be waiting for */

	} else if(strstr(xpath, "/"XML_TAG_TRANSIENT_NODEATTRS"[") \|\| safe_str_eq(name, XML_TAG_TRANSIENT_NODEATTRS)) {
	abort_unless_down(xpath, op, change, "Transient attribute change");
	break; /* Won't be packaged with any resource operations we may be waiting for */

	} else if(strstr(xpath, "/"XML_LRM_TAG_RSC_OP"[") && safe_str_eq(op, "delete")) {
	crm_action_t *cancel = NULL;
	char *mutable_key = strdup(xpath);
	char key, node_uuid;

	/* Extract the part of xpath between last pair of single quotes */
	key = strrchr(mutable_key, '\'');
	if (key != NULL) {
	*key = '\0';
	key = strrchr(mutable_key, '\'');
	}
	if (key == NULL) {
	crm_warn("Ignoring malformed CIB update (resource deletion)");
	free(mutable_key);
	continue;
	}
	++key;

	node_uuid = extract_node_uuid(xpath);
	cancel = get_cancel_action(key, node_uuid);
	if (cancel == NULL) {
	abort_transition(INFINITY, tg_restart, "Resource operation removal", change);

	} else {
	crm_info("Cancellation of %s on %s confirmed (%d)", key, node_uuid, cancel->id);
	stop_te_timer(cancel->timer);
	te_action_confirmed(cancel);

	update_graph(transition_graph, cancel);
	trigger_graph();

	}
	free(mutable_key);
	free(node_uuid);

	} else if(strstr(xpath, "/"XML_CIB_TAG_LRM"[") && safe_str_eq(op, "delete")) {
	abort_unless_down(xpath, op, change, "Resource state removal");

	} else if(strstr(xpath, "/"XML_CIB_TAG_STATE"[") && safe_str_eq(op, "delete")) {
	abort_unless_down(xpath, op, change, "Node state removal");

	} else if(name == NULL) {
	crm_debug("No result for %s operation to %s", op, xpath);
	CRM_ASSERT(strcmp(op, "delete") == 0 \|\| strcmp(op, "move") == 0);

	} else if(strcmp(name, XML_TAG_CIB) == 0) {
	xmlNode *state = NULL;
	xmlNode *status = first_named_child(match, XML_CIB_TAG_STATUS);
	xmlNode *config = first_named_child(match, XML_CIB_TAG_CONFIGURATION);

	for (state = __xml_first_child(status); state != NULL; state = __xml_next(state)) {
	xmlNode *lrm = first_named_child(state, XML_CIB_TAG_LRM);

	node = ID(state);
	process_resource_updates(node, lrm, change, op, xpath);
	}

	if(config) {
	abort_transition(INFINITY, tg_restart, "Non-status-only change", change);
	}

	} else if(strcmp(name, XML_CIB_TAG_STATUS) == 0) {
	xmlNode *state = NULL;

	for (state = __xml_first_child(match); state != NULL; state = __xml_next(state)) {
	xmlNode *lrm = first_named_child(state, XML_CIB_TAG_LRM);

	node = ID(state);
	process_resource_updates(node, lrm, change, op, xpath);
	}

	} else if(strcmp(name, XML_CIB_TAG_STATE) == 0) {
	xmlNode *lrm = first_named_child(match, XML_CIB_TAG_LRM);

	node = ID(match);
	process_resource_updates(node, lrm, change, op, xpath);

	} else if(strcmp(name, XML_CIB_TAG_LRM) == 0) {
	node = ID(match);
	process_resource_updates(node, match, change, op, xpath);

	} else if(strcmp(name, XML_LRM_TAG_RESOURCES) == 0) {
	char *local_node = get_node_from_xpath(xpath);

	process_resource_updates(local_node, match, change, op, xpath);
	free(local_node);

	} else if(strcmp(name, XML_LRM_TAG_RESOURCE) == 0) {

	xmlNode *rsc_op;
	char *local_node = get_node_from_xpath(xpath);

	for (rsc_op = __xml_first_child(match); rsc_op != NULL; rsc_op = __xml_next(rsc_op)) {
	process_graph_event(rsc_op, local_node);
	}
	free(local_node);

	} else if(strcmp(name, XML_LRM_TAG_RSC_OP) == 0) {
	char *local_node = get_node_from_xpath(xpath);

	process_graph_event(match, local_node);
	free(local_node);

	} else {
	crm_err("Ignoring %s operation for %s %p, %s", op, xpath, match, name);
	}
	}
	}


	gboolean
	process_te_message(xmlNode * msg, xmlNode * xml_data)
	{
	const char *from = crm_element_value(msg, F_ORIG);
	const char *sys_to = crm_element_value(msg, F_CRM_SYS_TO);
	const char *sys_from = crm_element_value(msg, F_CRM_SYS_FROM);
	const char *ref = crm_element_value(msg, F_CRM_REFERENCE);
	const char *op = crm_element_value(msg, F_CRM_TASK);
	const char *type = crm_element_value(msg, F_CRM_MSG_TYPE);

	crm_trace("Processing %s (%s) message", op, ref);
	crm_log_xml_trace(msg, "ipc");

	if (op == NULL) {
	/* error */

	} else if (sys_to == NULL \|\| strcasecmp(sys_to, CRM_SYSTEM_TENGINE) != 0) {
	crm_trace("Bad sys-to %s", crm_str(sys_to));
	return FALSE;

	} else if (safe_str_eq(op, CRM_OP_INVOKE_LRM)
	&& safe_str_eq(sys_from, CRM_SYSTEM_LRMD)
	/* && safe_str_eq(type, XML_ATTR_RESPONSE) */
	) {
	xmlXPathObject *xpathObj = NULL;

	crm_log_xml_trace(msg, "Processing (N)ACK");
	crm_debug("Processing (N)ACK %s from %s", crm_element_value(msg, F_CRM_REFERENCE), from);

	xpathObj = xpath_search(xml_data, "//" XML_LRM_TAG_RSC_OP);
	if (numXpathResults(xpathObj)) {
	int lpc = 0, max = numXpathResults(xpathObj);

	for (lpc = 0; lpc < max; lpc++) {
	xmlNode *rsc_op = getXpathResult(xpathObj, lpc);
	const char *node = get_node_id(rsc_op);

	process_graph_event(rsc_op, node);
	}
	freeXpathObject(xpathObj);

	} else {
	crm_log_xml_err(msg, "Invalid (N)ACK");
	freeXpathObject(xpathObj);
	return FALSE;
	}

	} else {
	crm_err("Unknown command: %s::%s from %s", type, op, sys_from);
	}

	crm_trace("finished processing message");

	return TRUE;
	}

	GHashTable *stonith_failures = NULL;
	struct st_fail_rec {
	int count;
	};

	static gboolean
	too_many_st_failures(const char *target)
	{
	GHashTableIter iter;
	const char *key = NULL;
	struct st_fail_rec *value = NULL;

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

	if (target == NULL) {
	g_hash_table_iter_init(&iter, stonith_failures);
	while (g_hash_table_iter_next(&iter, (gpointer ) & key, (gpointer ) & value)) {
	if (value->count >= stonith_max_attempts) {
	target = (const char*)key;
	goto too_many;
	}
	}
	} else {
	value = g_hash_table_lookup(stonith_failures, target);
	if ((value != NULL) && (value->count >= stonith_max_attempts)) {
	goto too_many;
	}
	}
	return FALSE;

	too_many:
	crm_warn("Too many failures (%d) to fence %s, giving up",
	value->count, target);
	return TRUE;
	}

	/*!
	* \internal
	* \brief Reset a stonith fail count
	*
	* \param[in] target Name of node to reset, or NULL for all
	*/
	void
	st_fail_count_reset(const char *target)
	{
	if (stonith_failures == NULL) {
	return;
	}

	if (target) {
	struct st_fail_rec *rec = NULL;

	rec = g_hash_table_lookup(stonith_failures, target);
	if (rec) {
	rec->count = 0;
	}
	} else {
	GHashTableIter iter;
	const char *key = NULL;
	struct st_fail_rec *rec = NULL;

	g_hash_table_iter_init(&iter, stonith_failures);
	while (g_hash_table_iter_next(&iter, (gpointer *) &key,
	(gpointer *) &rec)) {
	rec->count = 0;
	}
	}
	}

	void
	st_fail_count_increment(const char *target)
	{
	struct st_fail_rec *rec = NULL;

	if (stonith_failures == NULL) {
	stonith_failures =
	g_hash_table_new_full(crm_str_hash, g_str_equal, g_hash_destroy_str, free);
	}

	rec = g_hash_table_lookup(stonith_failures, target);
	if (rec) {
	rec->count++;
	} else {
	rec = malloc(sizeof(struct st_fail_rec));
	if(rec == NULL) {
	return;
	}

	rec->count = 1;
	g_hash_table_insert(stonith_failures, strdup(target), rec);
	}
	}

	/*!
	* \internal
	* \brief Abort transition due to stonith failure
	*
	* \param[in] abort_action Whether to restart or stop transition
	* \param[in] target Don't restart if this (NULL for any) has too many failures
	* \param[in] reason Log this stonith action XML as abort reason (or NULL)
	*/
	void
	abort_for_stonith_failure(enum transition_action abort_action,
	const char target, xmlNode reason)
	{
	/* If stonith repeatedly fails, we eventually give up on starting a new
	* transition for that reason.
	*/
	if ((abort_action != tg_stop) && too_many_st_failures(target)) {
	abort_action = tg_stop;
	}
	abort_transition(INFINITY, abort_action, "Stonith failed", reason);
	}

	void
	tengine_stonith_callback(stonith_t * stonith, stonith_callback_data_t * data)
	{
	char *uuid = NULL;
	int target_rc = -1;
	int stonith_id = -1;
	int transition_id = -1;
	crm_action_t *action = NULL;
	int call_id = data->call_id;
	int rc = data->rc;
	char *userdata = data->userdata;

	CRM_CHECK(userdata != NULL, return);
	crm_notice("Stonith operation %d/%s: %s (%d)", call_id, (char *)userdata,
	pcmk_strerror(rc), rc);

	if (AM_I_DC == FALSE) {
	return;
	}

	/* crm_info("call=%d, optype=%d, node_name=%s, result=%d, node_list=%s, action=%s", */
	/* op->call_id, op->optype, op->node_name, op->op_result, */
	/* (char )op->node_list, op->private_data); /

	/* filter out old STONITH actions */
	CRM_CHECK(decode_transition_key(userdata, &uuid, &transition_id, &stonith_id, &target_rc),
	crm_err("Invalid event detected");
	goto bail;
	);

	if (transition_graph->complete \|\| stonith_id < 0 \|\| safe_str_neq(uuid, te_uuid)
	\|\| transition_graph->id != transition_id) {
	crm_info("Ignoring STONITH action initiated outside of the current transition");
	goto bail;
	}

	action = get_action(stonith_id, FALSE);
	if (action == NULL) {
	crm_err("Stonith action not matched");
	goto bail;
	}

	stop_te_timer(action->timer);

	if (rc == pcmk_ok) {
	const char *target = crm_element_value(action->xml, XML_LRM_ATTR_TARGET);
	const char *uuid = crm_element_value(action->xml, XML_LRM_ATTR_TARGET_UUID);
	const char *op = crm_meta_value(action->params, "stonith_action");

	crm_debug("Stonith operation %d for %s passed", call_id, target);
	if (action->confirmed == FALSE) {
	te_action_confirmed(action);
	if (action->sent_update == FALSE && safe_str_neq("on", op)) {
	send_stonith_update(action, target, uuid);
	action->sent_update = TRUE;
	}
	}
	st_fail_count_reset(target);

	} else {
	const char *target = crm_element_value_const(action->xml, XML_LRM_ATTR_TARGET);
	enum transition_action abort_action = tg_restart;

	action->failed = TRUE;
	crm_notice("Stonith operation %d for %s failed (%s): aborting transition.",
	call_id, target, pcmk_strerror(rc));

	/* If no fence devices were available, there's no use in immediately
	* checking again, so don't start a new transition in that case.
	*/
	if (rc == -ENODEV) {
	crm_warn("No devices found in cluster to fence %s, giving up",
	target);
	abort_action = tg_stop;
	}

	+ /* Increment the fail count now, so abort_for_stonith_failure() can
	+ * check it. Non-DC nodes will increment it in tengine_stonith_notify().
	+ */
	+ st_fail_count_increment(target);
	abort_for_stonith_failure(abort_action, target, NULL);
	}

	update_graph(transition_graph, action);
	trigger_graph();

	bail:
	free(userdata);
	free(uuid);
	return;
	}

	void
	cib_fencing_updated(xmlNode * msg, int call_id, int rc, xmlNode * output, void *user_data)
	{
	if (rc < pcmk_ok) {
	crm_err("Fencing update %d for %s: failed - %s (%d)",
	call_id, (char *)user_data, pcmk_strerror(rc), rc);
	crm_log_xml_warn(msg, "Failed update");
	abort_transition(INFINITY, tg_shutdown, "CIB update failed", NULL);

	} else {
	crm_info("Fencing update %d for %s: complete", call_id, (char *)user_data);
	}
	}

	void
	cib_action_updated(xmlNode * msg, int call_id, int rc, xmlNode * output, void *user_data)
	{
	if (rc < pcmk_ok) {
	crm_err("Update %d FAILED: %s", call_id, pcmk_strerror(rc));
	}
	}

	gboolean
	action_timer_callback(gpointer data)
	{
	crm_action_timer_t *timer = NULL;

	CRM_CHECK(data != NULL, return FALSE);

	timer = (crm_action_timer_t *) data;
	stop_te_timer(timer);

	crm_warn("Timer popped (timeout=%d, abort_level=%d, complete=%s)",
	timer->timeout,
	transition_graph->abort_priority, transition_graph->complete ? "true" : "false");

	CRM_CHECK(timer->action != NULL, return FALSE);

	if (transition_graph->complete) {
	crm_warn("Ignoring timeout while not in transition");

	} else if (timer->reason == timeout_action_warn) {
	print_action(LOG_WARNING, "Action missed its timeout: ", timer->action);

	/* Don't check the FSA state
	*
	* We might also be in S_INTEGRATION or some other state waiting for this
	* action so we can close the transition and continue
	*/

	} else {
	/* fail the action */
	gboolean send_update = TRUE;
	const char *task = crm_element_value(timer->action->xml, XML_LRM_ATTR_TASK);

	print_action(LOG_ERR, "Aborting transition, action lost: ", timer->action);

	timer->action->failed = TRUE;
	te_action_confirmed(timer->action);
	abort_transition(INFINITY, tg_restart, "Action lost", NULL);

	update_graph(transition_graph, timer->action);
	trigger_graph();

	if (timer->action->type != action_type_rsc) {
	send_update = FALSE;
	} else if (safe_str_eq(task, RSC_CANCEL)) {
	/* we don't need to update the CIB with these */
	send_update = FALSE;
	}

	if (send_update) {
	cib_action_update(timer->action, PCMK_LRM_OP_TIMEOUT, PCMK_OCF_UNKNOWN_ERROR);
	}
	}

	return FALSE;
	}
	diff --git a/crmd/te_utils.c b/crmd/te_utils.c
	index 9fd4c9f0b4..5b13adc1db 100644
	--- a/crmd/te_utils.c
	+++ b/crmd/te_utils.c
	@@ -1,677 +1,681 @@
	/*
	* 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
	*/

	#include <crm_internal.h>

	#include <sys/param.h>
	#include <crm/crm.h>

	#include <crm/msg_xml.h>

	#include <crm/common/xml.h>
	#include <tengine.h>
	#include <crmd_fsa.h>
	#include <crmd_lrm.h>
	#include <crmd_messages.h>
	#include <throttle.h>
	#include <crm/fencing/internal.h>

	crm_trigger_t *stonith_reconnect = NULL;

	/*
	* stonith cleanup list
	*
	* If the DC is shot, proper notifications might not go out.
	* The stonith cleanup list allows the cluster to (re-)send
	* notifications once a new DC is elected.
	*/

	static GListPtr stonith_cleanup_list = NULL;

	/*!
	* \internal
	* \brief Add a node to the stonith cleanup list
	*
	* \param[in] target Name of node to add
	*/
	void
	add_stonith_cleanup(const char *target) {
	stonith_cleanup_list = g_list_append(stonith_cleanup_list, strdup(target));
	}

	/*!
	* \internal
	* \brief Remove a node from the stonith cleanup list
	*
	* \param[in] Name of node to remove
	*/
	void
	remove_stonith_cleanup(const char *target)
	{
	GListPtr iter = stonith_cleanup_list;

	while (iter != NULL) {
	GListPtr tmp = iter;
	char *iter_name = tmp->data;

	iter = iter->next;
	if (safe_str_eq(target, iter_name)) {
	crm_trace("Removing %s from the cleanup list", iter_name);
	stonith_cleanup_list = g_list_delete_link(stonith_cleanup_list, tmp);
	free(iter_name);
	}
	}
	}

	/*!
	* \internal
	* \brief Purge all entries from the stonith cleanup list
	*/
	void
	purge_stonith_cleanup()
	{
	if (stonith_cleanup_list) {
	GListPtr iter = NULL;

	for (iter = stonith_cleanup_list; iter != NULL; iter = iter->next) {
	char *target = iter->data;

	crm_info("Purging %s from stonith cleanup list", target);
	free(target);
	}
	g_list_free(stonith_cleanup_list);
	stonith_cleanup_list = NULL;
	}
	}

	/*!
	* \internal
	* \brief Send stonith updates for all entries in cleanup list, then purge it
	*/
	void
	execute_stonith_cleanup()
	{
	GListPtr iter;

	for (iter = stonith_cleanup_list; iter != NULL; iter = iter->next) {
	char *target = iter->data;
	crm_node_t *target_node = crm_get_peer(0, target);
	const char *uuid = crm_peer_uuid(target_node);

	crm_notice("Marking %s, target of a previous stonith action, as clean", target);
	send_stonith_update(NULL, target, uuid);
	free(target);
	}
	g_list_free(stonith_cleanup_list);
	stonith_cleanup_list = NULL;
	}

	/* end stonith cleanup list functions */

	static gboolean
	fail_incompletable_stonith(crm_graph_t * graph)
	{
	GListPtr lpc = NULL;
	const char *task = NULL;
	xmlNode *last_action = NULL;

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

	for (lpc = graph->synapses; lpc != NULL; lpc = lpc->next) {
	GListPtr lpc2 = NULL;
	synapse_t synapse = (synapse_t ) lpc->data;

	if (synapse->confirmed) {
	continue;
	}

	for (lpc2 = synapse->actions; lpc2 != NULL; lpc2 = lpc2->next) {
	crm_action_t action = (crm_action_t ) lpc2->data;

	if (action->type != action_type_crm \|\| action->confirmed) {
	continue;
	}

	task = crm_element_value(action->xml, XML_LRM_ATTR_TASK);
	if (task && safe_str_eq(task, CRM_OP_FENCE)) {
	action->failed = TRUE;
	last_action = action->xml;
	update_graph(graph, action);
	crm_notice("Failing action %d (%s): STONITHd terminated",
	action->id, ID(action->xml));
	}
	}
	}

	if (last_action != NULL) {
	crm_warn("STONITHd failure resulted in un-runnable actions");
	abort_for_stonith_failure(tg_restart, NULL, last_action);
	return TRUE;
	}

	return FALSE;
	}

	static void
	tengine_stonith_connection_destroy(stonith_t * st, stonith_event_t * e)
	{
	if (is_set(fsa_input_register, R_ST_REQUIRED)) {
	crm_crit("Fencing daemon connection failed");
	mainloop_set_trigger(stonith_reconnect);

	} else {
	crm_info("Fencing daemon disconnected");
	}

	/* cbchan will be garbage at this point, arrange for it to be reset */
	if(stonith_api) {
	stonith_api->state = stonith_disconnected;
	}

	if (AM_I_DC) {
	fail_incompletable_stonith(transition_graph);
	trigger_graph();
	}
	}

	#if SUPPORT_CMAN
	# include <libfenced.h>
	#endif

	char *te_client_id = NULL;

	#ifdef HAVE_SYS_REBOOT_H
	# include <unistd.h>
	# include <sys/reboot.h>
	#endif

	static void
	tengine_stonith_notify(stonith_t * st, stonith_event_t * st_event)
	{
	if(te_client_id == NULL) {
	te_client_id = crm_strdup_printf("%s.%d", crm_system_name, getpid());
	}

	if (st_event == NULL) {
	crm_err("Notify data not found");
	return;
	}

	crmd_alert_fencing_op(st_event);

	if (st_event->result == pcmk_ok && safe_str_eq("on", st_event->action)) {
	crm_notice("%s was successfully unfenced by %s (at the request of %s)",
	st_event->target, st_event->executioner ? st_event->executioner : "<anyone>", st_event->origin);
	/* TODO: Hook up st_event->device */
	return;

	} else if (safe_str_eq("on", st_event->action)) {
	crm_err("Unfencing of %s by %s failed: %s (%d)",
	st_event->target, st_event->executioner ? st_event->executioner : "<anyone>",
	pcmk_strerror(st_event->result), st_event->result);
	return;

	} else if (st_event->result == pcmk_ok && crm_str_eq(st_event->target, fsa_our_uname, TRUE)) {
	crm_crit("We were allegedly just fenced by %s for %s!",
	st_event->executioner ? st_event->executioner : "<anyone>", st_event->origin); /* Dumps blackbox if enabled */

	qb_log_fini(); /* Try to get the above log message to disk - somehow */

	/* Get out ASAP and do not come back up.
	*
	* Triggering a reboot is also not the worst idea either since
	* the rest of the cluster thinks we're safely down
	*/

	#ifdef RB_HALT_SYSTEM
	reboot(RB_HALT_SYSTEM);
	#endif

	/*
	* If reboot() fails or is not supported, coming back up will
	* probably lead to a situation where the other nodes set our
	* status to 'lost' because of the fencing callback and will
	* discard subsequent election votes with:
	*
	* Election 87 (current: 5171, owner: 103): Processed vote from east-03 (Peer is not part of our cluster)
	*
	* So just stay dead, something is seriously messed up anyway.
	*
	*/
	exit(100); /* None of our wrappers since we already called qb_log_fini() */
	return;
	}

	- if (safe_str_eq(st_event->operation, T_STONITH_NOTIFY_FENCE)) {
	+ /* Update the count of stonith failures for this target, in case we become
	+ * DC later. The current DC has already updated its fail count in
	+ * tengine_stonith_callback().
	+ */
	+ if (!AM_I_DC && safe_str_eq(st_event->operation, T_STONITH_NOTIFY_FENCE)) {
	if (st_event->result == pcmk_ok) {
	st_fail_count_reset(st_event->target);
	} else {
	st_fail_count_increment(st_event->target);
	}
	}

	crm_notice("Peer %s was%s terminated (%s) by %s on behalf of %s: %s "
	CRM_XS " initiator=%s ref=%s",
	st_event->target, st_event->result == pcmk_ok ? "" : " not",
	st_event->action,
	st_event->executioner ? st_event->executioner : "<anyone>",
	(st_event->client_origin? st_event->client_origin : "<unknown>"),
	pcmk_strerror(st_event->result),
	st_event->origin, st_event->id);

	#if SUPPORT_CMAN
	if (st_event->result == pcmk_ok && is_cman_cluster()) {
	int local_rc = 0;
	int confirm = 0;
	char *target_copy = strdup(st_event->target);

	/* In case fenced hasn't noticed yet
	*
	* Any fencing that has been inititated will be completed by way of the fence_pcmk redirect
	*/
	local_rc = fenced_external(target_copy);
	if (local_rc != 0) {
	crm_err("Could not notify CMAN that '%s' is now fenced: %d", st_event->target,
	local_rc);
	} else {
	crm_notice("Notified CMAN that '%s' is now fenced", st_event->target);
	}

	/* In case fenced is already trying to shoot it */
	confirm = open("/var/run/cluster/fenced_override", O_NONBLOCK\|O_WRONLY);
	if (confirm >= 0) {
	int ignore = 0;
	int len = strlen(target_copy);

	errno = 0;
	local_rc = write(confirm, target_copy, len);
	ignore = write(confirm, "\n", 1);

	if(ignore < 0 && errno == EBADF) {
	crm_trace("CMAN not expecting %s to be fenced (yet)", st_event->target);

	} else if (local_rc < len) {
	crm_perror(LOG_ERR, "Confirmation of CMAN fencing event for '%s' failed: %d", st_event->target, local_rc);

	} else {
	fsync(confirm);
	crm_notice("Confirmed CMAN fencing event for '%s'", st_event->target);
	}
	close(confirm);
	}
	free(target_copy);
	}
	#endif

	if (st_event->result == pcmk_ok) {
	crm_node_t *peer = crm_find_peer_full(0, st_event->target, CRM_GET_PEER_ANY);
	const char *uuid = NULL;
	gboolean we_are_executioner = safe_str_eq(st_event->executioner, fsa_our_uname);

	if (peer == NULL) {
	return;
	}

	uuid = crm_peer_uuid(peer);

	crm_trace("target=%s dc=%s", st_event->target, fsa_our_dc);
	if(AM_I_DC) {
	/* The DC always sends updates */
	send_stonith_update(NULL, st_event->target, uuid);

	/* @TODO Ideally, at this point, we'd check whether the fenced node
	* hosted any guest nodes, and call remote_node_down() for them.
	* Unfortunately, the crmd doesn't have a simple, reliable way to
	* map hosts to guests. It might be possible to track this in the
	* peer cache via crm_remote_peer_cache_refresh(). For now, we rely
	* on the PE creating fence pseudo-events for the guests.
	*/

	if (st_event->client_origin && safe_str_neq(st_event->client_origin, te_client_id)) {

	/* Abort the current transition graph if it wasn't us
	* that invoked stonith to fence someone
	*/
	crm_info("External fencing operation from %s fenced %s", st_event->client_origin, st_event->target);
	abort_transition(INFINITY, tg_restart, "External Fencing Operation", NULL);
	}

	/* Assume it was our leader if we don't currently have one */
	} else if (((fsa_our_dc == NULL) \|\| safe_str_eq(fsa_our_dc, st_event->target))
	&& !is_set(peer->flags, crm_remote_node)) {

	crm_notice("Target %s our leader %s (recorded: %s)",
	fsa_our_dc ? "was" : "may have been", st_event->target,
	fsa_our_dc ? fsa_our_dc : "<unset>");

	/* Given the CIB resyncing that occurs around elections,
	* have one node update the CIB now and, if the new DC is different,
	* have them do so too after the election
	*/
	if (we_are_executioner) {
	send_stonith_update(NULL, st_event->target, uuid);
	}
	add_stonith_cleanup(st_event->target);
	}

	/* If the target is a remote node, and we host its connection,
	* immediately fail all monitors so it can be recovered quickly.
	* The connection won't necessarily drop when a remote node is fenced,
	* so the failure might not otherwise be detected until the next poke.
	*/
	if (is_set(peer->flags, crm_remote_node)) {
	remote_ra_fail(st_event->target);
	}

	crmd_peer_down(peer, TRUE);
	}
	}

	gboolean
	te_connect_stonith(gpointer user_data)
	{
	int lpc = 0;
	int rc = pcmk_ok;

	if (stonith_api == NULL) {
	stonith_api = stonith_api_new();
	}

	if (stonith_api->state != stonith_disconnected) {
	crm_trace("Still connected");
	return TRUE;
	}

	for (lpc = 0; lpc < 30; lpc++) {
	crm_debug("Attempting connection to fencing daemon...");

	sleep(1);
	rc = stonith_api->cmds->connect(stonith_api, crm_system_name, NULL);

	if (rc == pcmk_ok) {
	break;
	}

	if (user_data != NULL) {
	if (is_set(fsa_input_register, R_ST_REQUIRED)) {
	crm_err("Sign-in failed: triggered a retry");
	mainloop_set_trigger(stonith_reconnect);
	} else {
	crm_info("Sign-in failed, but no longer required");
	}
	return TRUE;
	}

	crm_err("Sign-in failed: pausing and trying again in 2s...");
	sleep(1);
	}

	CRM_CHECK(rc == pcmk_ok, return TRUE); /* If not, we failed 30 times... just get out */
	stonith_api->cmds->register_notification(stonith_api, T_STONITH_NOTIFY_DISCONNECT,
	tengine_stonith_connection_destroy);

	stonith_api->cmds->register_notification(stonith_api, T_STONITH_NOTIFY_FENCE,
	tengine_stonith_notify);

	crm_trace("Connected");
	return TRUE;
	}

	gboolean
	stop_te_timer(crm_action_timer_t * timer)
	{
	const char *timer_desc = "action timer";

	if (timer == NULL) {
	return FALSE;
	}
	if (timer->reason == timeout_abort) {
	timer_desc = "global timer";
	crm_trace("Stopping %s", timer_desc);
	}

	if (timer->source_id != 0) {
	crm_trace("Stopping %s", timer_desc);
	g_source_remove(timer->source_id);
	timer->source_id = 0;

	} else {
	crm_trace("%s was already stopped", timer_desc);
	return FALSE;
	}

	return TRUE;
	}

	gboolean
	te_graph_trigger(gpointer user_data)
	{
	enum transition_status graph_rc = -1;

	if (transition_graph == NULL) {
	crm_debug("Nothing to do");
	return TRUE;
	}

	crm_trace("Invoking graph %d in state %s", transition_graph->id, fsa_state2string(fsa_state));

	switch (fsa_state) {
	case S_STARTING:
	case S_PENDING:
	case S_NOT_DC:
	case S_HALT:
	case S_ILLEGAL:
	case S_STOPPING:
	case S_TERMINATE:
	return TRUE;
	break;
	default:
	break;
	}

	if (transition_graph->complete == FALSE) {
	int limit = transition_graph->batch_limit;

	transition_graph->batch_limit = throttle_get_total_job_limit(limit);
	graph_rc = run_graph(transition_graph);
	transition_graph->batch_limit = limit; /* Restore the configured value */

	/* significant overhead... */
	/* print_graph(LOG_DEBUG_3, transition_graph); */

	if (graph_rc == transition_active) {
	crm_trace("Transition not yet complete");
	return TRUE;

	} else if (graph_rc == transition_pending) {
	crm_trace("Transition not yet complete - no actions fired");
	return TRUE;
	}

	if (graph_rc != transition_complete) {
	crm_warn("Transition failed: %s", transition_status(graph_rc));
	print_graph(LOG_NOTICE, transition_graph);
	}
	}

	crm_debug("Transition %d is now complete", transition_graph->id);
	transition_graph->complete = TRUE;
	notify_crmd(transition_graph);

	return TRUE;
	}

	void
	trigger_graph_processing(const char *fn, int line)
	{
	crm_trace("%s:%d - Triggered graph processing", fn, line);
	mainloop_set_trigger(transition_trigger);
	}

	void
	abort_transition_graph(int abort_priority, enum transition_action abort_action,
	const char abort_text, xmlNode reason, const char *fn, int line)
	{
	int add[] = { 0, 0, 0 };
	int del[] = { 0, 0, 0 };
	int level = LOG_INFO;
	xmlNode *diff = NULL;
	xmlNode *change = NULL;

	CRM_CHECK(transition_graph != NULL, return);

	switch (fsa_state) {
	case S_STARTING:
	case S_PENDING:
	case S_NOT_DC:
	case S_HALT:
	case S_ILLEGAL:
	case S_STOPPING:
	case S_TERMINATE:
	crm_info("Abort %s suppressed: state=%s (complete=%d)",
	abort_text, fsa_state2string(fsa_state), transition_graph->complete);
	return;
	default:
	break;
	}

	/* Make sure any queued calculations are discarded ASAP */
	free(fsa_pe_ref);
	fsa_pe_ref = NULL;

	if (transition_graph->complete == FALSE) {
	if(update_abort_priority(transition_graph, abort_priority, abort_action, abort_text)) {
	level = LOG_NOTICE;
	}
	}

	if(reason) {
	xmlNode *search = NULL;

	for(search = reason; search; search = search->parent) {
	if (safe_str_eq(XML_TAG_DIFF, TYPE(search))) {
	diff = search;
	break;
	}
	}

	if(diff) {
	xml_patch_versions(diff, add, del);
	for(search = reason; search; search = search->parent) {
	if (safe_str_eq(XML_DIFF_CHANGE, TYPE(search))) {
	change = search;
	break;
	}
	}
	}
	}

	if(reason == NULL) {
	do_crm_log(level, "Transition aborted: %s "CRM_XS" source=%s:%d complete=%s",
	abort_text, fn, line,
	(transition_graph->complete? "true" : "false"));

	} else if(change == NULL) {
	char *local_path = xml_get_path(reason);

	do_crm_log(level, "Transition aborted by %s.%s: %s "
	CRM_XS " cib=%d.%d.%d source=%s:%d path=%s complete=%s",
	TYPE(reason), ID(reason), abort_text,
	add[0], add[1], add[2], fn, line, local_path,
	(transition_graph->complete? "true" : "false"));
	free(local_path);

	} else {
	const char *kind = NULL;
	const char *op = crm_element_value(change, XML_DIFF_OP);
	const char *path = crm_element_value(change, XML_DIFF_PATH);

	if(change == reason) {
	if(strcmp(op, "create") == 0) {
	reason = reason->children;

	} else if(strcmp(op, "modify") == 0) {
	reason = first_named_child(reason, XML_DIFF_RESULT);
	if(reason) {
	reason = reason->children;
	}
	}
	}

	kind = TYPE(reason);
	if(strcmp(op, "delete") == 0) {
	const char *shortpath = strrchr(path, '/');

	do_crm_log(level, "Transition aborted by deletion of %s: %s "
	CRM_XS " cib=%d.%d.%d source=%s:%d path=%s complete=%s",
	(shortpath? (shortpath + 1) : path), abort_text,
	add[0], add[1], add[2], fn, line, path,
	(transition_graph->complete? "true" : "false"));

	} else if (safe_str_eq(XML_CIB_TAG_NVPAIR, kind)) {
	do_crm_log(level, "Transition aborted by %s doing %s %s=%s: %s "
	CRM_XS " cib=%d.%d.%d source=%s:%d path=%s complete=%s",
	crm_element_value(reason, XML_ATTR_ID), op,
	crm_element_value(reason, XML_NVPAIR_ATTR_NAME),
	crm_element_value(reason, XML_NVPAIR_ATTR_VALUE),
	abort_text, add[0], add[1], add[2], fn, line, path,
	(transition_graph->complete? "true" : "false"));

	} else if (safe_str_eq(XML_LRM_TAG_RSC_OP, kind)) {
	const char *magic = crm_element_value(reason, XML_ATTR_TRANSITION_MAGIC);

	do_crm_log(level, "Transition aborted by operation %s '%s' on %s: %s "
	CRM_XS " magic=%s cib=%d.%d.%d source=%s:%d complete=%s",
	crm_element_value(reason, XML_LRM_ATTR_TASK_KEY), op,
	crm_element_value(reason, XML_LRM_ATTR_TARGET), abort_text,
	magic, add[0], add[1], add[2], fn, line,
	(transition_graph->complete? "true" : "false"));

	} else if (safe_str_eq(XML_CIB_TAG_STATE, kind)
	\|\| safe_str_eq(XML_CIB_TAG_NODE, kind)) {
	const char *uname = crm_peer_uname(ID(reason));

	do_crm_log(level, "Transition aborted by %s '%s' on %s: %s "
	CRM_XS " cib=%d.%d.%d source=%s:%d complete=%s",
	kind, op, (uname? uname : ID(reason)), abort_text,
	add[0], add[1], add[2], fn, line,
	(transition_graph->complete? "true" : "false"));

	} else {
	do_crm_log(level, "Transition aborted by %s.%s '%s': %s "
	CRM_XS " cib=%d.%d.%d source=%s:%d path=%s complete=%s",
	TYPE(reason), ID(reason), (op? op : "change"), abort_text,
	add[0], add[1], add[2], fn, line, path,
	(transition_graph->complete? "true" : "false"));
	}
	}

	if (transition_graph->complete) {
	if (transition_timer->period_ms > 0) {
	crm_timer_stop(transition_timer);
	crm_timer_start(transition_timer);
	} else {
	register_fsa_input(C_FSA_INTERNAL, I_PE_CALC, NULL);
	}
	return;
	}

	mainloop_set_trigger(transition_trigger);
	}

File Metadata

Mime Type: text/x-diff
Expires: Thu, Jul 10, 1:07 AM (8 h, 46 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 2009417
Default Alt Text: (52 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions