No OneTemporary
Actions

Size

45 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/crmd/te_actions.c b/crmd/te_actions.c
	index ae52448243..2d8a47e87e 100644
	--- a/crmd/te_actions.c
	+++ b/crmd/te_actions.c
	@@ -1,570 +1,568 @@
	/*
	* 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.1 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	*/

	#include <crm_internal.h>

	#include <sys/param.h>
	#include <crm/crm.h>
	#include <crm/cib.h>
	#include <crm/msg_xml.h>
	#include <crm/common/msg.h>
	#include <crm/common/xml.h>
	#include <tengine.h>

	#include <crmd_fsa.h>
	#include <crmd_messages.h>
	#include <crm/common/cluster.h>

	char *te_uuid = NULL;

	void send_rsc_command(crm_action_t *action);

	static void
	te_start_action_timer(crm_graph_t graph, crm_action_t action)
	{
	crm_malloc0(action->timer, sizeof(crm_action_timer_t));
	action->timer->timeout = action->timeout;
	action->timer->reason = timeout_action;
	action->timer->action = action;
	action->timer->source_id = g_timeout_add(
	action->timer->timeout + graph->network_delay,
	action_timer_callback, (void*)action->timer);

	CRM_ASSERT(action->timer->source_id != 0);
	}


	static gboolean
	te_pseudo_action(crm_graph_t graph, crm_action_t pseudo)
	{
	crm_info("Pseudo action %d fired and confirmed", pseudo->id);
	pseudo->confirmed = TRUE;
	update_graph(graph, pseudo);
	trigger_graph();
	return TRUE;
	}

	void
	-send_stonith_update(crm_action_t *action)
	+send_stonith_update(crm_action_t action, const char target, const char *uuid)
	{
	enum cib_errors rc = cib_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);

	/* zero out the node-status & remove all LRM status info */
	xmlNode *node_state = create_xml_node(NULL, XML_CIB_TAG_STATE);

	CRM_CHECK(target != NULL, return);
	CRM_CHECK(uuid != NULL, return);

	crm_xml_add(node_state, XML_ATTR_UUID, uuid);
	crm_xml_add(node_state, XML_ATTR_UNAME, target);
	crm_xml_add(node_state, XML_CIB_ATTR_HASTATE, DEADSTATUS);
	crm_xml_add(node_state, XML_CIB_ATTR_INCCM, XML_BOOLEAN_NO);
	crm_xml_add(node_state, XML_CIB_ATTR_CRMDSTATE, OFFLINESTATUS);
	crm_xml_add(node_state, XML_CIB_ATTR_JOINSTATE, CRMD_JOINSTATE_DOWN);
	crm_xml_add(node_state, XML_CIB_ATTR_EXPSTATE, CRMD_JOINSTATE_DOWN);
	crm_xml_add(node_state, XML_ATTR_ORIGIN, __FUNCTION__);

	rc = fsa_cib_conn->cmds->update(
	fsa_cib_conn, XML_CIB_TAG_STATUS, node_state,
	cib_quorum_override\|cib_scope_local\|cib_can_create);

	if(rc < cib_ok) {
	crm_err("CIB update failed: %s", cib_error2string(rc));
	abort_transition(
	INFINITY, tg_shutdown, "CIB update failed", node_state);

	} else {
	/* delay processing the trigger until the update completes */
	add_cib_op_callback(fsa_cib_conn, rc, FALSE, crm_strdup(target), cib_fencing_updated);
	}

	erase_status_tag(target, XML_CIB_TAG_LRM);
	erase_status_tag(target, XML_TAG_TRANSIENT_NODEATTRS);

	free_xml(node_state);

	#if 0
	/* Make sure the membership cache is accurate */
	crm_update_peer(0, 0, 0, -1, 0, uuid, target, NULL, CRM_NODE_LOST);
	#endif

	return;
	}

	static gboolean
	te_fence_node(crm_graph_t graph, crm_action_t action)
	{
	int rc = 0;
	const char *id = NULL;
	const char *uuid = NULL;
	const char *target = NULL;
	const char *type = NULL;
	gboolean invalid_action = FALSE;

	id = ID(action->xml);
	target = crm_element_value(action->xml, XML_LRM_ATTR_TARGET);
	uuid = crm_element_value(action->xml, XML_LRM_ATTR_TARGET_UUID);
	type = crm_meta_value(action->params, "stonith_action");

	CRM_CHECK(id != NULL, invalid_action = TRUE);
	CRM_CHECK(uuid != NULL, invalid_action = TRUE);
	CRM_CHECK(type != NULL, invalid_action = TRUE);
	CRM_CHECK(target != NULL, invalid_action = TRUE);

	if(invalid_action) {
	crm_log_xml_warn(action->xml, "BadAction");
	return FALSE;
	}

	te_log_action(LOG_INFO,
	"Executing %s fencing operation (%s) on %s (timeout=%d)",
	type, id, target, transition_graph->stonith_timeout);

	/* Passing NULL means block until we can connect... */
	te_connect_stonith(NULL);

	if(type == NULL) {
	type = "reboot";
	}

	rc = stonith_api->cmds->fence(
	stonith_api, 0, target, action->params, type, transition_graph->stonith_timeout/1000);

	stonith_api->cmds->register_callback(
	stonith_api, rc, transition_graph->stonith_timeout/1000, FALSE,
	generate_transition_key(transition_graph->id, action->id, 0, te_uuid),
	"tengine_stonith_callback", tengine_stonith_callback);

	return TRUE;
	}

	static int get_target_rc(crm_action_t *action)
	{
	const char *target_rc_s = crm_meta_value(action->params, XML_ATTR_TE_TARGET_RC);

	if(target_rc_s != NULL) {
	return crm_parse_int(target_rc_s, "0");
	}
	return 0;
	}

	static gboolean
	te_crm_command(crm_graph_t graph, crm_action_t action)
	{
	char *counter = NULL;
	xmlNode *cmd = NULL;
	gboolean is_local = FALSE;

	const char *id = NULL;
	const char *task = NULL;
	const char *value = NULL;
	const char *on_node = NULL;

	gboolean rc = TRUE;
	gboolean no_wait = FALSE;

	id = ID(action->xml);
	task = crm_element_value(action->xml, XML_LRM_ATTR_TASK);
	on_node = crm_element_value(action->xml, XML_LRM_ATTR_TARGET);

	CRM_CHECK(on_node != NULL && strlen(on_node) != 0,
	te_log_action(LOG_ERR, "Corrupted command (id=%s) %s: no node",
	crm_str(id), crm_str(task));
	return FALSE);

	te_log_action(LOG_INFO, "Executing crm-event (%s): %s on %s%s%s",
	crm_str(id), crm_str(task), on_node,
	is_local?" (local)":"", no_wait?" - no waiting":"");

	if(safe_str_eq(on_node, fsa_our_uname)) {
	is_local = TRUE;
	}

	value = crm_meta_value(action->params, XML_ATTR_TE_NOWAIT);
	if(crm_is_true(value)) {
	no_wait = TRUE;
	}

	if(is_local && safe_str_eq(task, CRM_OP_SHUTDOWN)) {
	/* defer until everything else completes */
	te_log_action(LOG_INFO, "crm-event (%s) is a local shutdown", crm_str(id));
	graph->completion_action = tg_shutdown;
	graph->abort_reason = "local shutdown";
	action->confirmed = TRUE;
	update_graph(graph, action);
	trigger_graph();
	return TRUE;
	}

	cmd = create_request(task, NULL, on_node, CRM_SYSTEM_CRMD,
	CRM_SYSTEM_TENGINE, NULL);

	counter = generate_transition_key(
	transition_graph->id, action->id, get_target_rc(action), te_uuid);
	crm_xml_add(cmd, XML_ATTR_TRANSITION_KEY, counter);

	rc = send_cluster_message(on_node, crm_msg_crmd, cmd, TRUE);
	crm_free(counter);
	free_xml(cmd);

	value = crm_meta_value(action->params, XML_ATTR_TE_NOWAIT);
	if(rc == FALSE) {
	crm_err("Action %d failed: send", action->id);
	return FALSE;

	} else if(no_wait) {
	action->confirmed = TRUE;
	update_graph(graph, action);
	trigger_graph();

	} else {
	if(action->timeout <= 0) {
	crm_err("Action %d: %s on %s had an invalid timeout (%dms). Using %dms instead",
	action->id, task, on_node, action->timeout, graph->network_delay);
	action->timeout = graph->network_delay;
	}
	te_start_action_timer(graph, action);
	}

	return TRUE;
	}

	gboolean
	cib_action_update(crm_action_t *action, int status, int op_rc)
	{
	char *op_id = NULL;
	char *code = NULL;
	char *digest = NULL;
	xmlNode *tmp = NULL;
	xmlNode *params = NULL;
	xmlNode *state = NULL;
	xmlNode *rsc = NULL;
	xmlNode *xml_op = NULL;
	xmlNode *action_rsc = NULL;

	enum cib_errors rc = cib_ok;

	const char *name = NULL;
	const char *value = NULL;
	const char *rsc_id = NULL;
	const char *task = crm_element_value(action->xml, XML_LRM_ATTR_TASK);
	const char *target = crm_element_value(action->xml, XML_LRM_ATTR_TARGET);
	const char *task_uuid = crm_element_value(action->xml, XML_LRM_ATTR_TASK_KEY);
	const char *target_uuid = crm_element_value(action->xml, XML_LRM_ATTR_TARGET_UUID);

	int call_options = cib_quorum_override\|cib_scope_local;

	if(status == LRM_OP_PENDING) {
	crm_debug("%s %d: Recording pending operation %s on %s",
	crm_element_name(action->xml), action->id, task_uuid, target);
	} else {
	crm_warn("%s %d: %s on %s timed out",
	crm_element_name(action->xml), action->id, task_uuid, target);
	}

	action_rsc = find_xml_node(action->xml, XML_CIB_TAG_RESOURCE, TRUE);
	if(action_rsc == NULL) {
	return FALSE;
	}

	rsc_id = ID(action_rsc);
	CRM_CHECK(rsc_id != NULL,
	crm_log_xml_err(action->xml, "Bad:action");
	return FALSE);

	/*
	update the CIB

	<node_state id="hadev">
	<lrm>
	<lrm_resources>
	<lrm_resource id="rsc2" last_op="start" op_code="0" target="hadev"/>
	*/

	state = create_xml_node(NULL, XML_CIB_TAG_STATE);

	crm_xml_add(state, XML_ATTR_UUID, target_uuid);
	crm_xml_add(state, XML_ATTR_UNAME, target);

	rsc = create_xml_node(state, XML_CIB_TAG_LRM);
	crm_xml_add(rsc, XML_ATTR_ID, target_uuid);

	rsc = create_xml_node(rsc, XML_LRM_TAG_RESOURCES);
	rsc = create_xml_node(rsc, XML_LRM_TAG_RESOURCE);
	crm_xml_add(rsc, XML_ATTR_ID, rsc_id);

	name = XML_ATTR_TYPE;
	value = crm_element_value(action_rsc, name);
	crm_xml_add(rsc, name, value);
	name = XML_AGENT_ATTR_CLASS;
	value = crm_element_value(action_rsc, name);
	crm_xml_add(rsc, name, value);
	name = XML_AGENT_ATTR_PROVIDER;
	value = crm_element_value(action_rsc, name);
	crm_xml_add(rsc, name, value);

	xml_op = create_xml_node(rsc, XML_LRM_TAG_RSC_OP);
	crm_xml_add(xml_op, XML_ATTR_ID, task);

	op_id = generate_op_key(rsc_id, task, action->interval);
	crm_xml_add(xml_op, XML_ATTR_ID, op_id);
	crm_free(op_id);

	crm_xml_add_int(xml_op, XML_LRM_ATTR_CALLID, -1);
	crm_xml_add(xml_op, XML_LRM_ATTR_TASK, task);
	crm_xml_add(xml_op, XML_ATTR_CRM_VERSION, CRM_FEATURE_SET);
	crm_xml_add_int(xml_op, XML_LRM_ATTR_OPSTATUS, status);
	crm_xml_add_int(xml_op, XML_LRM_ATTR_INTERVAL, action->interval);
	crm_xml_add_int(xml_op, XML_LRM_ATTR_RC, op_rc);
	crm_xml_add(xml_op, XML_ATTR_ORIGIN, __FUNCTION__);

	if(crm_str_eq(task, CRMD_ACTION_MIGRATED, TRUE)) {
	char *key = crm_meta_name("migrate_source_uuid");
	xmlNode *attrs = first_named_child(action->xml, XML_TAG_ATTRS);
	const char *host = crm_element_value(attrs, key);
	CRM_CHECK(host != NULL, crm_log_xml_err(action->xml, "Bad Op"));
	crm_xml_add(xml_op, CRMD_ACTION_MIGRATED, host);
	crm_free(key);
	}

	code = generate_transition_key(
	transition_graph->id, action->id, get_target_rc(action), te_uuid);
	crm_xml_add(xml_op, XML_ATTR_TRANSITION_KEY, code);
	crm_free(code);

	code = generate_transition_magic(
	crm_element_value(xml_op, XML_ATTR_TRANSITION_KEY), status, op_rc);
	crm_xml_add(xml_op, XML_ATTR_TRANSITION_MAGIC, code);
	crm_free(code);

	tmp = find_xml_node(action->xml, "attributes", TRUE);
	params = create_xml_node(NULL, XML_TAG_PARAMS);
	copy_in_properties(params, tmp);

	filter_action_parameters(params, CRM_FEATURE_SET);
	digest = calculate_xml_digest(params, TRUE, FALSE);

	/* info for now as this area has been problematic to debug */
	crm_debug("Calculated digest %s for %s (%s)\n",
	digest, ID(xml_op),
	crm_element_value(xml_op, XML_ATTR_TRANSITION_MAGIC));
	crm_log_xml(LOG_DEBUG, "digest:source", params);

	crm_xml_add(xml_op, XML_LRM_ATTR_OP_DIGEST, digest);
	crm_free(digest);
	free_xml(params);

	crm_debug_3("Updating CIB with \"%s\" (%s): %s %s on %s",
	status<0?"new action":XML_ATTR_TIMEOUT,
	crm_element_name(action->xml), crm_str(task), rsc_id, target);

	rc = fsa_cib_conn->cmds->update(
	fsa_cib_conn, XML_CIB_TAG_STATUS, state, call_options);

	crm_debug_2("Updating CIB with %s action %d: %s on %s (call_id=%d)",
	op_status2text(status), action->id, task_uuid, target, rc);

	add_cib_op_callback(fsa_cib_conn, rc, FALSE, NULL, cib_action_updated);
	free_xml(state);

	action->sent_update = TRUE;

	if(rc < cib_ok) {
	return FALSE;
	}

	return TRUE;
	}


	static gboolean
	te_rsc_command(crm_graph_t graph, crm_action_t action)
	{
	/* never overwrite stop actions in the CIB with
	* anything other than completed results
	*
	* Writing pending stops makes it look like the
	* resource is running again
	*/
	xmlNode *cmd = NULL;
	xmlNode *rsc_op = NULL;

	gboolean rc = TRUE;
	gboolean no_wait = FALSE;
	gboolean is_local = FALSE;

	char *counter = NULL;
	const char *task = NULL;
	const char *value = NULL;
	const char *on_node = NULL;
	const char *task_uuid = NULL;

	CRM_ASSERT(action != NULL);
	CRM_ASSERT(action->xml != NULL);

	action->executed = FALSE;
	on_node = crm_element_value(action->xml, XML_LRM_ATTR_TARGET);

	CRM_CHECK(on_node != NULL && strlen(on_node) != 0,
	te_log_action(LOG_ERR, "Corrupted command(id=%s) %s: no node",
	ID(action->xml), crm_str(task));
	return FALSE);

	rsc_op = action->xml;
	task = crm_element_value(rsc_op, XML_LRM_ATTR_TASK);
	task_uuid = crm_element_value(action->xml, XML_LRM_ATTR_TASK_KEY);
	on_node = crm_element_value(rsc_op, XML_LRM_ATTR_TARGET);
	counter = generate_transition_key(
	transition_graph->id, action->id, get_target_rc(action), te_uuid);
	crm_xml_add(rsc_op, XML_ATTR_TRANSITION_KEY, counter);

	if(safe_str_eq(on_node, fsa_our_uname)) {
	is_local = TRUE;
	}

	value = crm_meta_value(action->params, XML_ATTR_TE_NOWAIT);
	if(crm_is_true(value)) {
	no_wait = TRUE;
	}

	crm_info("Initiating action %d: %s %s on %s%s%s",
	action->id, task, task_uuid, on_node,
	is_local?" (local)":"", no_wait?" - no waiting":"");

	cmd = create_request(CRM_OP_INVOKE_LRM, rsc_op, on_node,
	CRM_SYSTEM_LRMD, CRM_SYSTEM_TENGINE, NULL);

	if(is_local) {
	/* shortcut local resource commands */
	ha_msg_input_t data = {
	.msg = cmd,
	.xml = rsc_op,
	};

	fsa_data_t msg = {
	.id = 0,
	.data = &data,
	.data_type = fsa_dt_ha_msg,
	.fsa_input = I_NULL,
	.fsa_cause = C_FSA_INTERNAL,
	.actions = A_LRM_INVOKE,
	.origin = __FUNCTION__,
	};

	do_lrm_invoke(A_LRM_INVOKE, C_FSA_INTERNAL, fsa_state, I_NULL, &msg);

	} else {
	rc = send_cluster_message(on_node, crm_msg_lrmd, cmd, TRUE);
	}

	crm_free(counter);
	free_xml(cmd);

	action->executed = TRUE;
	if(rc == FALSE) {
	crm_err("Action %d failed: send", action->id);
	return FALSE;

	} else if(no_wait) {
	action->confirmed = TRUE;
	update_graph(transition_graph, action);
	trigger_graph();

	} else {
	if(action->timeout <= 0) {
	crm_err("Action %d: %s %s on %s had an invalid timeout (%dms). Using %dms instead",
	action->id, task, task_uuid, on_node, action->timeout, graph->network_delay);
	action->timeout = graph->network_delay;
	}
	te_start_action_timer(graph, action);
	}

	value = crm_meta_value(action->params, XML_OP_ATTR_PENDING);
	if(crm_is_true(value)) {
	/* write a "pending" entry to the CIB, inhibit notification */
	crm_info("Recording pending op %s in the CIB", task_uuid);
	cib_action_update(action, LRM_OP_PENDING, EXECRA_STATUS_UNKNOWN);
	}

	return TRUE;
	}

	crm_graph_functions_t te_graph_fns = {
	te_pseudo_action,
	te_rsc_command,
	te_crm_command,
	te_fence_node
	};

	void
	notify_crmd(crm_graph_t *graph)
	{
	int log_level = LOG_DEBUG;
	const char *type = "unknown";
	enum crmd_fsa_input event = I_NULL;

	crm_debug("Processing transition completion in state %s", fsa_state2string(fsa_state));

	CRM_CHECK(graph->complete, graph->complete = TRUE);

	switch(graph->completion_action) {
	case tg_stop:
	type = "stop";
	/* fall through */
	case tg_done:
	type = "done";
	log_level = LOG_INFO;
	if(fsa_state == S_TRANSITION_ENGINE) {
	event = I_TE_SUCCESS;
	}
	break;

	case tg_restart:
	type = "restart";
	if(fsa_state == S_TRANSITION_ENGINE) {
	event = I_PE_CALC;

	} else if(fsa_state == S_POLICY_ENGINE) {
	register_fsa_action(A_PE_INVOKE);
	}
	break;

	case tg_shutdown:
	type = "shutdown";
	if(is_set(fsa_input_register, R_SHUTDOWN)) {
	event = I_STOP;

	} else {
	event = I_TERMINATE;
	}
	}

	te_log_action(log_level, "Transition %d status: %s - %s",
	graph->id, type, crm_str(graph->abort_reason));

	graph->abort_reason = NULL;
	graph->completion_action = tg_done;
	clear_bit_inplace(fsa_input_register, R_IN_TRANSITION);

	if(event != I_NULL) {
	register_fsa_input(C_FSA_INTERNAL, event, NULL);
	}

	}
	diff --git a/crmd/te_callbacks.c b/crmd/te_callbacks.c
	index 665730122b..28481a5043 100644
	--- a/crmd/te_callbacks.c
	+++ b/crmd/te_callbacks.c
	@@ -1,502 +1,503 @@
	/*
	* 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.1 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	*/

	#include <crm_internal.h>

	#include <sys/stat.h>

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

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

	#include <crm/common/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;

	/* #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);
	}


	static void process_resource_updates(xmlXPathObject *xpathObj)
	{
	/*
	<status>
	<node_state id="node1" state=CRMD_STATE_ACTIVE exp_state="active">
	<lrm>
	<lrm_resources>
	<rsc_state id="" rsc_id="rsc4" node_id="node1" rsc_state="stopped"/>
	*/
	int lpc = 0, max = xpathObj->nodesetval->nodeNr;
	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);
	}
	}

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

	xmlNode *diff = NULL;
	xmlNode *cib_top = NULL;
	xmlXPathObject *xpathObj = NULL;

	int diff_add_updates = 0;
	int diff_add_epoch = 0;
	int diff_add_admin_epoch = 0;

	int diff_del_updates = 0;
	int diff_del_epoch = 0;
	int diff_del_admin_epoch = 0;

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

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

	} else if(rc < cib_ok) {
	crm_debug_3("Filter rc=%d (%s)", rc, cib_error2string(rc));
	return;

	} else if(transition_graph->complete == TRUE
	&& fsa_state != S_IDLE
	&& fsa_state != S_TRANSITION_ENGINE
	&& fsa_state != S_POLICY_ENGINE) {
	crm_debug_2("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);

	cib_diff_version_details(
	diff,
	&diff_add_admin_epoch, &diff_add_epoch, &diff_add_updates,
	&diff_del_admin_epoch, &diff_del_epoch, &diff_del_updates);

	crm_debug("Processing diff (%s): %d.%d.%d -> %d.%d.%d (%s)", op,
	diff_del_admin_epoch,diff_del_epoch,diff_del_updates,
	diff_add_admin_epoch,diff_add_epoch,diff_add_updates,
	fsa_state2string(fsa_state));
	log_cib_diff(LOG_DEBUG_2, diff, op);

	/* Process crm_config updates */
	cib_top = get_xpath_object("//"F_CIB_UPDATE_RESULT"//"XML_TAG_DIFF_ADDED"//"XML_CIB_TAG_CRMCONFIG, diff, LOG_DEBUG);
	if(cib_top != NULL) {
	mainloop_set_trigger(config_read);
	}

	/* Process anything that was added */
	cib_top = get_xpath_object("//"F_CIB_UPDATE_RESULT"//"XML_TAG_DIFF_ADDED"//"XML_TAG_CIB, diff, LOG_ERR);
	if(need_abort(cib_top)) {
	goto bail; /* configuration changed */
	}

	/* Process anything that was removed */
	cib_top = get_xpath_object("//"F_CIB_UPDATE_RESULT"//"XML_TAG_DIFF_REMOVED"//"XML_TAG_CIB, diff, LOG_ERR);
	if(need_abort(cib_top)) {
	goto bail; /* configuration changed */
	}

	/* Transient Attributes - Added/Updated */
	xpathObj = xpath_search(diff,"//"F_CIB_UPDATE_RESULT"//"XML_TAG_DIFF_ADDED"//"XML_TAG_TRANSIENT_NODEATTRS);
	if(xpathObj && xpathObj->nodesetval->nodeNr > 0) {
	xmlNode *aborted = getXpathResult(xpathObj, 0);
	abort_transition(INFINITY, tg_restart, "Transient attribute: update", aborted);
	goto bail;

	} else if(xpathObj) {
	xmlXPathFreeObject(xpathObj);
	}

	/* Transient Attributes - Removed */
	xpathObj = xpath_search(diff,"//"F_CIB_UPDATE_RESULT"//"XML_TAG_DIFF_REMOVED"//"XML_TAG_TRANSIENT_NODEATTRS);
	if(xpathObj && xpathObj->nodesetval->nodeNr > 0) {
	xmlNode *aborted = getXpathResult(xpathObj, 0);
	abort_transition(INFINITY, tg_restart, "Transient attribute: removal", aborted);
	goto bail;

	} else if(xpathObj) {
	xmlXPathFreeObject(xpathObj);
	}

	/* Check for node state updates... possibly from a shutdown we requested */
	xpathObj = xpath_search(diff, "//"F_CIB_UPDATE_RESULT"//"XML_TAG_DIFF_ADDED"//"XML_CIB_TAG_STATE);
	if(xpathObj) {
	int lpc = 0, max = xpathObj->nodesetval->nodeNr;
	for(lpc = 0; lpc < max; lpc++) {
	xmlNode *node = getXpathResult(xpathObj, lpc);
	const char *event_node = crm_element_value(node, XML_ATTR_ID);
	const char *ccm_state = crm_element_value(node, XML_CIB_ATTR_INCCM);
	const char *ha_state = crm_element_value(node, XML_CIB_ATTR_HASTATE);
	const char *shutdown_s = crm_element_value(node, XML_CIB_ATTR_SHUTDOWN);
	const char *crmd_state = crm_element_value(node, XML_CIB_ATTR_CRMDSTATE);

	if(safe_str_eq(ccm_state, XML_BOOLEAN_FALSE)
	\|\| safe_str_eq(ha_state, DEADSTATUS)
	\|\| safe_str_eq(crmd_state, CRMD_JOINSTATE_DOWN)) {
	crm_action_t *shutdown = match_down_event(0, event_node, NULL);

	if(shutdown != NULL) {
	const char *task = crm_element_value(shutdown->xml, XML_LRM_ATTR_TASK);
	if(safe_str_neq(task, CRM_OP_FENCE)) {
	/* Wait for stonithd to tell us it is complete via tengine_stonith_callback() */
	crm_debug("Confirming %s op %d", task, shutdown->id);
	/* match->confirmed = TRUE; */
	stop_te_timer(shutdown->timer);
	update_graph(transition_graph, shutdown);
	trigger_graph();
	}

	} else {
	crm_info("Stonith/shutdown of %s not matched", event_node);
	abort_transition(INFINITY, tg_restart, "Node failure", node);
	}
	fail_incompletable_actions(transition_graph, event_node);
	}

	if(shutdown_s) {
	int shutdown = crm_parse_int(shutdown_s, NULL);
	if(shutdown > 0) {
	crm_info("Aborting on "XML_CIB_ATTR_SHUTDOWN" attribute for %s", event_node);
	abort_transition(INFINITY, tg_restart, "Shutdown request", node);
	}
	}
	}
	xmlXPathFreeObject(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);
	}

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

	/* Process operation updates */
	xpathObj = xpath_search(diff, "//"F_CIB_UPDATE_RESULT"//"XML_TAG_DIFF_ADDED"//"XML_LRM_TAG_RSC_OP);
	if(xpathObj) {
	process_resource_updates(xpathObj);
	xmlXPathFreeObject(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);
	if(xpathObj) {
	int lpc = 0, max = xpathObj->nodesetval->nodeNr;

	for(lpc = 0; lpc < max; lpc++) {
	int max = 0;
	const char *op_id = NULL;
	char *rsc_op_xpath = NULL;
	xmlXPathObject *op_match = NULL;
	xmlNode *match = getXpathResult(xpathObj, lpc);
	CRM_CHECK(match != NULL, continue);

	op_id = ID(match);

	max = strlen(rsc_op_template) + strlen(op_id) + 1;
	crm_malloc0(rsc_op_xpath, max);
	snprintf(rsc_op_xpath, max, rsc_op_template, op_id);

	op_match = xpath_search(diff, rsc_op_xpath);
	if(op_match == NULL \|\| op_match->nodesetval->nodeNr == 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);
	goto bail;

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

	if(op_match) {
	xmlXPathFreeObject(op_match);
	}
	crm_free(rsc_op_xpath);
	}
	}

	bail:
	if(xpathObj) {
	xmlXPathFreeObject(xpathObj);
	}
	}

	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, XML_ATTR_REFERENCE);
	const char *op = crm_element_value(msg, F_CRM_TASK);
	const char *type = crm_element_value(msg, F_CRM_MSG_TYPE);

	crm_debug_2("Processing %s (%s) message", op, ref);
	crm_log_xml(LOG_DEBUG_3, "ipc", msg);

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

	} else if(sys_to == NULL \|\| strcasecmp(sys_to, CRM_SYSTEM_TENGINE) != 0) {
	crm_debug_2("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(LOG_DEBUG_2, "Processing (N)ACK", msg);
	crm_info("Processing (N)ACK %s from %s",
	crm_element_value(msg, XML_ATTR_REFERENCE), from);

	xpathObj = xpath_search(xml_data, "//"XML_LRM_TAG_RSC_OP);
	if(xpathObj) {
	process_resource_updates(xpathObj);
	xmlXPathFreeObject(xpathObj);
	xpathObj = NULL;

	} else {
	crm_log_xml(LOG_ERR, "Invalid (N)ACK", msg);
	return FALSE;
	}

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

	crm_debug_3("finished processing message");

	return TRUE;
	}

	void
	tengine_stonith_callback(
	stonith_t stonith, const xmlNode msg, int call_id, int rc, xmlNode output, void userdata)
	{
	char *uuid = NULL;
	int target_rc = -1;
	int stonith_id = -1;
	int transition_id = -1;
	crm_action_t *action = NULL;

	CRM_CHECK(userdata != NULL, return);
	crm_log_xml_info(output, "StonithOp");
	crm_info("Stonith operation %d/%s: %s (%d)", call_id, (char*)userdata, stonith_error2string(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;
	}

	/* this will mark the event complete if a match is found */
	action = get_action(stonith_id, TRUE);
	if(action == NULL) {
	crm_err("Stonith action not matched");
	goto bail;
	}

	if(rc == stonith_ok) {
	- crm_info("Stonith of %s passed",
	- crm_element_value_const(action->xml, XML_LRM_ATTR_TARGET));
	- send_stonith_update(action);
	+ 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);
	+ crm_info("Stonith of %s passed", target);
	+ send_stonith_update(action, target, uuid);

	} else {
	const char *target = crm_element_value_const(action->xml, XML_LRM_ATTR_TARGET);
	const char *allow_fail = crm_meta_value(action->params, XML_ATTR_TE_ALLOWFAIL);

	action->failed = TRUE;
	if(crm_is_true(allow_fail) == FALSE) {
	crm_err("Stonith of %s failed (%d)... aborting transition.", target, rc);
	abort_transition(INFINITY, tg_restart, "Stonith failed", NULL);
	}
	}

	update_graph(transition_graph, action);
	trigger_graph();

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

	void
	cib_fencing_updated(xmlNode *msg, int call_id, int rc,
	xmlNode output, void user_data)
	{
	if(rc < cib_ok) {
	crm_err("CIB update failed: %s", cib_error2string(rc));
	crm_log_xml_warn(msg, "Failed update");
	}
	crm_free(user_data);
	}

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

	void
	cib_failcount_updated(xmlNode *msg, int call_id, int rc,
	xmlNode output, void user_data)
	{
	if(rc < cib_ok) {
	crm_err("Update %d FAILED: %s", call_id, cib_error2string(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);

	} else if(fsa_state != S_TRANSITION_ENGINE && fsa_state != S_POLICY_ENGINE) {
	crm_err("Discarding action timeout in state: %s", fsa_state2string(fsa_state));

	} else if(transition_graph->complete) {
	crm_err("Ignoring action timeout while not in transition");

	} 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;
	timer->action->confirmed = TRUE;
	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, "cancel")) {
	/* we dont need to update the CIB with these */
	send_update = FALSE;
	} else if(safe_str_eq(task, "stop")) {
	/* never update the CIB with these */
	send_update = FALSE;
	}

	if(send_update) {
	/* cib_action_update(timer->action, LRM_OP_PENDING, EXECRA_STATUS_UNKNOWN); */
	cib_action_update(timer->action, LRM_OP_TIMEOUT, EXECRA_UNKNOWN_ERROR);
	}
	}

	return FALSE;
	}



	diff --git a/crmd/te_utils.c b/crmd/te_utils.c
	index f75a634a05..8ebf929346 100644
	--- a/crmd/te_utils.c
	+++ b/crmd/te_utils.c
	@@ -1,310 +1,342 @@
	/*
	* 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.1 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	*/

	#include <crm_internal.h>

	#include <sys/param.h>
	#include <crm/crm.h>
	#include <crm/cib.h>
	#include <crm/msg_xml.h>
	#include <crm/common/msg.h>
	#include <crm/common/xml.h>
	#include <tengine.h>
	#include <crmd_fsa.h>
	#include <crmd_messages.h>

	GCHSource *stonith_src = NULL;
	crm_trigger_t *stonith_reconnect = NULL;

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

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

	slist_iter(
	synapse, synapse_t, graph->synapses, lpc,
	if (synapse->confirmed) {
	continue;
	}

	slist_iter(
	action, crm_action_t, synapse->actions, lpc,

	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_transition(INFINITY, tg_restart, "Stonith failure", last_action);
	return TRUE;
	}

	return FALSE;
	}

	static void
	tengine_stonith_connection_destroy(stonith_t st, const char event, xmlNode *msg)
	{
	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 */
	stonith_api->state = stonith_disconnected;

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

	+/*
	+<notify t="st_notify" subt="st_fence" st_op="st_fence" st_rc="0" >
	+ <st_calldata >
	+ <st-reply st_origin="stonith_construct_reply" t="stonith-ng" st_rc="0" st_op="st_query" st_callid="0" st_clientid="09fcbd8b-156a-4727-ab37-4f8b2071847c" st_remote_op="1230801d-dba5-42ac-8e2c-bf444fb2a401" st_callopt="0" st_delegate="pcmk-4" >
	+ <st_calldata >
	+ <st-reply st_origin="stonith_construct_async_reply" t="stonith-ng" st_op="reboot" st_remote_op="1230801d-dba5-42ac-8e2c-bf444fb2a401" st_callid="0" st_callopt="0" st_rc="0" src="pcmk-4" seq="2" state="0" st_target="pcmk-1" />
	+*/
	+
	static void
	tengine_stonith_notify(stonith_t st, const char event, xmlNode *msg)
	{
	- crm_log_xml_info(msg, event);
	+ int rc = -99;
	+ const char *target = NULL;
	+ xmlNode *action = get_xpath_object("//@src", msg, LOG_ERR);
	+
	+ if(action == NULL) {
	+ crm_log_xml(LOG_ERR, "Notify data not found", msg);
	+ return;
	+ }
	+
	+ crm_element_value_int(action, F_STONITH_RC, &rc);
	+ target = crm_element_value(action, F_STONITH_TARGET);
	+
	+ crm_info("%s was terminated (%s) by %s for %s: %d (reference: %s)",
	+ target,
	+ crm_element_value(action, F_STONITH_OPERATION),
	+ crm_element_value(action, F_STONITH_DELEGATE),
	+ crm_element_value(action, "src"),
	+ rc,
	+ crm_element_value(action, F_STONITH_REMOTE));
	+
	+ if(rc == stonith_ok && safe_str_eq(target, fsa_our_dc)) {
	+ const char *uuid = get_uuid(target);
	+ crm_notice("Target was our leader %s/%s", target, uuid);
	+ /* send_stonith_update(action, target, uuid); */
	+ }
	}

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

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

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

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

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

	if(rc == stonith_ok) {
	break;
	}

	if(user_data != NULL) {
	crm_err("Sign-in failed: triggered a retry");
	mainloop_set_trigger(stonith_reconnect);
	return TRUE;
	}

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

	CRM_CHECK(rc == stonith_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, STONITH_OP_FENCE, tengine_stonith_notify);

	crm_info("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_debug_2("Stopping %s", timer_desc);
	}

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

	} else {
	crm_debug_2("%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_debug_2("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) {
	graph_rc = run_graph(transition_graph);
	print_graph(LOG_DEBUG_3, transition_graph);

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

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

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

	crm_info("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)
	{
	mainloop_set_trigger(transition_trigger);
	crm_debug_2("%s:%d - Triggered graph processing", fn, line);
	}

	void
	abort_transition_graph(
	int abort_priority, enum transition_action abort_action,
	const char abort_text, xmlNode reason, const char *fn, int line)
	{
	int log_level = LOG_INFO;
	const char *magic = NULL;
	CRM_CHECK(transition_graph != NULL, return);

	if(reason) {
	int diff_add_updates = 0;
	int diff_add_epoch = 0;
	int diff_add_admin_epoch = 0;

	int diff_del_updates = 0;
	int diff_del_epoch = 0;
	int diff_del_admin_epoch = 0;
	xmlNode *diff = get_xpath_object("//"F_CIB_UPDATE_RESULT"//diff", reason, LOG_DEBUG_2);
	magic = crm_element_value(reason, XML_ATTR_TRANSITION_MAGIC);

	if(diff) {
	cib_diff_version_details(
	diff,
	&diff_add_admin_epoch, &diff_add_epoch, &diff_add_updates,
	&diff_del_admin_epoch, &diff_del_epoch, &diff_del_updates);
	do_crm_log(log_level,
	"%s:%d - Triggered transition abort (complete=%d, tag=%s, id=%s, magic=%s, cib=%d.%d.%d) : %s",
	fn, line, transition_graph->complete, TYPE(reason), ID(reason), magic?magic:"NA",
	diff_add_admin_epoch,diff_add_epoch,diff_add_updates, abort_text);

	} else {
	do_crm_log(log_level,
	"%s:%d - Triggered transition abort (complete=%d, tag=%s, id=%s, magic=%s) : %s",
	fn, line, transition_graph->complete, TYPE(reason), ID(reason), magic?magic:"NA", abort_text);
	}

	} else {
	do_crm_log(log_level,
	"%s:%d - Triggered transition abort (complete=%d) : %s",
	fn, line, transition_graph->complete, abort_text);
	}

	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:
	do_crm_log(log_level,
	"Abort suppressed: state=%s (complete=%d)",
	fsa_state2string(fsa_state), transition_graph->complete);
	return;
	default:
	break;
	}

	if(magic == NULL && reason != NULL) {
	crm_log_xml(log_level+1, "Cause", reason);
	}

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

	if(transition_graph->complete) {
	register_fsa_input(C_FSA_INTERNAL, I_PE_CALC, NULL);
	return;
	}

	update_abort_priority(
	transition_graph, abort_priority, abort_action, abort_text);

	mainloop_set_trigger(transition_trigger);
	}

	diff --git a/crmd/tengine.h b/crmd/tengine.h
	index 9fa9346794..ea2f10c9be 100644
	--- a/crmd/tengine.h
	+++ b/crmd/tengine.h
	@@ -1,76 +1,76 @@
	/*
	* 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.1 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	*/
	#ifndef TENGINE__H
	#define TENGINE__H

	#include <crm/transition.h>
	#include <crm/common/mainloop.h>
	#include <crm/stonith-ng.h>
	extern stonith_t *stonith_api;
	-extern void send_stonith_update(crm_action_t *stonith_action);
	+extern void send_stonith_update(crm_action_t stonith_action, const char target, const char *uuid);

	/* tengine */
	extern crm_action_t *match_down_event(
	int rc, const char target, const char filter);
	extern crm_action_t get_cancel_action(const char id, const char *node);

	extern gboolean cib_action_update(crm_action_t *action, int status, int op_rc);
	extern gboolean fail_incompletable_actions(crm_graph_t graph, const char down_node);
	extern gboolean need_abort(xmlNode *update);
	extern gboolean process_graph_event(xmlNode event, const char event_node);

	/* utils */
	extern crm_action_t *get_action(int id, gboolean confirmed);
	extern gboolean start_global_timer(crm_action_timer_t *timer, int timeout);
	extern gboolean stop_te_timer(crm_action_timer_t *timer);
	extern const char get_rsc_state(const char task, op_status_t status);

	/* unpack */
	extern gboolean process_te_message(xmlNode * msg, xmlNode *xml_data);

	extern crm_graph_t *transition_graph;
	extern crm_trigger_t *transition_trigger;

	extern char *te_uuid;

	extern void notify_crmd(crm_graph_t *graph);

	#include <te_callbacks.h>

	extern void trigger_graph_processing(const char *fn, int line);
	extern void abort_transition_graph(
	int abort_priority, enum transition_action abort_action,
	const char abort_text, xmlNode reason, const char *fn, int line);

	#define trigger_graph() trigger_graph_processing(__FUNCTION__, __LINE__)
	#define abort_transition(pri, action, text, reason) \
	abort_transition_graph(pri, action, text, reason,__FUNCTION__,__LINE__);

	extern gboolean te_connect_stonith(gpointer user_data);
	extern GCHSource *stonith_src;

	extern crm_trigger_t *transition_trigger;
	extern crm_trigger_t *stonith_reconnect;
	extern crm_action_timer_t *transition_timer;

	extern char *failed_stop_offset;
	extern char *failed_start_offset;
	extern int active_timeout;
	extern int stonith_op_active;
	#endif

File Metadata

Mime Type: text/x-diff
Expires: Tue, Jul 8, 6:17 PM (12 h, 15 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 2002564
Default Alt Text: (45 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions