Attachment #101927 for bug #152776

View | Details | Raw Unified | Return to bug 152776 | Differences between
Collapse All | Expand All




}

static void
update_failcount(crm_data_t *event, const char *event_node, int rc) 
{
	crm_data_t *rsc = NULL;
	char *attr_name = NULL;
	
	char *task     = NULL;
	char *rsc_id   = NULL;
	const char *on_node  = event_node;
	const char *on_uuid  = event_node;
	int interval = 0;

	if(rc == 99) {
		/* this is an internal code for "we're busy, try again" */
		return;
	}

	interval = g_hash_table_lookup(
		action->params, crm_meta_name("interval"));
	if(interval == NULL) {
		return;
	}

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

	rsc = find_xml_node(action->xml, XML_CIB_TAG_RESOURCE, TRUE);
	CRM_CHECK(rsc != NULL, return);
	rsc_id = ID(rsc);
	CRM_CHECK(rsc_id != NULL, return);
	
	task   = crm_element_value(action->xml, XML_LRM_ATTR_TASK);
	on_node = crm_element_value(action->xml, XML_LRM_ATTR_TARGET);
	on_uuid = crm_element_value(action->xml, XML_LRM_ATTR_TARGET_UUID);

	CRM_CHECK(task != NULL, return);
	CRM_CHECK(on_uuid != NULL, return);

	CRM_CHECK(parse_op_key(ID(event), &rsc_id, &task, &interval),return);
	CRM_CHECK(task != NULL, crm_free(rsc_id); return);
	CRM_CHECK(rsc_id != NULL, crm_free(task); return);
	/* CRM_CHECK(on_node != NULL, return); */
	
	if(interval > 0) {
		attr_name = crm_concat("fail-count", rsc_id, '-');
		crm_warn("Updating failcount for %s on %s after failed %s: rc=%d",
			 rsc_id, on_node, task, rc);
	
		update_attr(te_cib_conn, cib_none, XML_CIB_TAG_STATUS,
			    on_uuid, NULL,NULL, attr_name,
			    XML_NVPAIR_ATTR_VALUE"++");
		crm_free(attr_name);	
	}

	crm_free(rsc_id);
	crm_free(task);
}

static int
status_from_rc(crm_action_t *action, int orig_status, int rc)
{
	int status = orig_status;
	const char *target_rc_s = g_hash_table_lookup(
		action->params, crm_meta_name(XML_ATTR_TE_TARGET_RC));

	if(target_rc_s != NULL) {
		int target_rc = 0;
		crm_debug_2("Target rc: %s vs. %d", target_rc_s, rc);
		target_rc = crm_parse_int(target_rc_s, NULL);
		if(target_rc == rc) {
			crm_debug_2("Target rc: == %d", rc);
			if(status != LRM_OP_DONE) {
				crm_debug_2("Re-mapping op status to"
					    " LRM_OP_DONE for rc=%d", rc);
				status = LRM_OP_DONE;
			}
		} else {
			crm_debug_2("Target rc: != %d", rc);
			if(status != LRM_OP_ERROR) {
				crm_info("Re-mapping op status to"
					 " LRM_OP_ERROR for rc=%d", rc);
				status = LRM_OP_ERROR;
			}
		}
	}
	
	/* 99 is the code we use for direct nack's */
	if(rc != 99 && status != LRM_OP_DONE) {
		const char *task, *uname;
		task = crm_element_value(action->xml, XML_LRM_ATTR_TASK);
		uname  = crm_element_value(action->xml, XML_LRM_ATTR_TARGET);
		crm_warn("Action %s on %s failed (target: %s vs. rc: %d): %s",
			 task, uname, target_rc_s, rc, op_status2text(status));
	}

	return status;
}

/*

match_graph_event(
	crm_action_t *action, crm_data_t *event, const char *event_node)
{
	int log_level_fail = LOG_ERR;
	int target_rc = 0;
	const char *target_rc_s = NULL;
	const char *allow_fail  = NULL;
	const char *this_action = NULL;
	const char *this_node   = NULL;

		crm_debug_2("Action %d : Node mismatch %s (%s) vs. %s",
			    action->id, this_node, this_uname, event_node);
		return -1;
	}
	

	crm_debug_2("Matched action (%d) %s", action->id, this_event);

	CRM_CHECK(decode_transition_magic(
			       magic, &update_te_uuid,
			       &transition_i, &op_status_i, &op_rc_i), return -2);

	op_status_i = status_from_rc(action, op_status_i, op_rc_i);
	if(op_status_i != LRM_OP_DONE) {
		update_failcount(event, event_node, op_rc_i);
	}
	
	if(transition_i == -1) {
		/* we never expect these - recompute */
		crm_err("Detected action %s initiated outside of a transition",

	/* stop this event's timer if it had one */
	stop_te_timer(action->timer);
	action->confirmed = TRUE;

	target_rc_s = g_hash_table_lookup(
		action->params,crm_meta_name(XML_ATTR_TE_TARGET_RC));
	if(target_rc_s != NULL) {
		crm_debug_2("Target rc: %s vs. %d", target_rc_s, op_rc_i);
		target_rc = crm_parse_int(target_rc_s, NULL);
		if(target_rc == op_rc_i) {
			crm_debug_2("Target rc: == %d", op_rc_i);
			if(op_status_i != LRM_OP_DONE) {
				crm_debug_2("Re-mapping op status to"
					    " LRM_OP_DONE for %s",update_event);
				op_status_i = LRM_OP_DONE;
			}
		} else {
			crm_debug_2("Target rc: != %d", op_rc_i);
			if(op_status_i != LRM_OP_ERROR) {
				crm_info("Re-mapping op status to"
					 " LRM_OP_ERROR for %s", update_event);
				op_status_i = LRM_OP_ERROR;
			}
		}
	}
	
	/* Process OP status */
	switch(op_status_i) {

		case LRM_OP_DONE:
			break;
		case LRM_OP_ERROR:
			/* This is the code we use for direct nack's */
			if(op_rc_i == 99) {
				log_level_fail = LOG_WARNING;
			}
			/* fall through */
		case LRM_OP_TIMEOUT:
		case LRM_OP_NOTSUPPORTED:
			action->failed = TRUE;
			crm_log_maybe(log_level_fail,
				"Action %s on %s failed (target: %d vs. rc: %d): %s",
				update_event, this_uname, target_rc,
				op_rc_i, op_status2text(op_status_i));
			break;
		case LRM_OP_CANCELLED:
			/* do nothing?? */

	}

	if(action->failed) {
		/* ignore probes */
		if(target_rc != EXECRA_NOT_RUNNING) {
			update_failcount(action, op_rc_i);
		}
		abort_transition(action->synapse->priority+1,
				 tg_restart, "Event failed", event);


	/* unexpected event, trigger a pe-recompute */
	/* possibly do this only for certain types of actions */
	crm_warn("Event not found.");
	if(rc != EXECRA_OK) {
		update_failcount(event, event_node, rc);
	}
	crm_log_xml_info(event, "match:not-found");
	abort_transition(INFINITY, tg_restart, "Unexpected event", event);
	return;

Return to bug 152776

Lines 198-248 extract_event(crm_data_t *msg) Link Here

(-)a/crm/tengine/events.c (-77 / +76 lines)
198	}	198	}
199		199
200	static void	200	static void
201	update_failcount(crm_action_t *action, int rc)	201	update_failcount(crm_data_t event, const char event_node, int rc)
202	{	202	{
203	crm_data_t *rsc = NULL;
204	char *attr_name = NULL;	203	char *attr_name = NULL;
205		204
206	const char *task = NULL;	205	char *task = NULL;
207	const char *rsc_id = NULL;	206	char *rsc_id = NULL;
208	const char *on_node = NULL;	207	const char *on_node = event_node;
209	const char *on_uuid = NULL;	208	const char *on_uuid = event_node;
210	const char *interval = NULL;	209	int interval = 0;
211		210
212	if(rc == 99) {	211	if(rc == 99) {
213	/* this is an internal code for "we're busy, try again" */	212	/* this is an internal code for "we're busy, try again" */
214	return;	213	return;
215	}	214	}
216		215
217	interval = g_hash_table_lookup(
218	action->params, crm_meta_name("interval"));
219	if(interval == NULL) {
220	return;
221	}
222
223	CRM_CHECK(action->xml != NULL, return);
224
225	rsc = find_xml_node(action->xml, XML_CIB_TAG_RESOURCE, TRUE);
226	CRM_CHECK(rsc != NULL, return);
227	rsc_id = ID(rsc);
228	CRM_CHECK(rsc_id != NULL, return);
229
230	task = crm_element_value(action->xml, XML_LRM_ATTR_TASK);
231	on_node = crm_element_value(action->xml, XML_LRM_ATTR_TARGET);
232	on_uuid = crm_element_value(action->xml, XML_LRM_ATTR_TARGET_UUID);
233
234	CRM_CHECK(task != NULL, return);
235	CRM_CHECK(on_uuid != NULL, return);	216	CRM_CHECK(on_uuid != NULL, return);
236	CRM_CHECK(on_node != NULL, return);	217
237		218	CRM_CHECK(parse_op_key(ID(event), &rsc_id, &task, &interval),return);
238	attr_name = crm_concat("fail-count", rsc_id, '-');	219	CRM_CHECK(task != NULL, crm_free(rsc_id); return);
239	crm_warn("Updating failcount for %s on %s after failed %s: rc=%d",	220	CRM_CHECK(rsc_id != NULL, crm_free(task); return);
240	rsc_id, on_node, task, rc);	221	/* CRM_CHECK(on_node != NULL, return); */
241		222
242	update_attr(te_cib_conn, cib_none, XML_CIB_TAG_STATUS,	223	if(interval > 0) {
243	on_uuid, NULL,NULL, attr_name, XML_NVPAIR_ATTR_VALUE"++");	224	attr_name = crm_concat("fail-count", rsc_id, '-');
244		225	crm_warn("Updating failcount for %s on %s after failed %s: rc=%d",
245	crm_free(attr_name);	226	rsc_id, on_node, task, rc);
		227
		228	update_attr(te_cib_conn, cib_none, XML_CIB_TAG_STATUS,
		229	on_uuid, NULL,NULL, attr_name,
		230	XML_NVPAIR_ATTR_VALUE"++");
		231	crm_free(attr_name);
		232	}
		233
		234	crm_free(rsc_id);
		235	crm_free(task);
		236	}
		237
		238	static int
		239	status_from_rc(crm_action_t *action, int orig_status, int rc)
		240	{
		241	int status = orig_status;
		242	const char *target_rc_s = g_hash_table_lookup(
		243	action->params, crm_meta_name(XML_ATTR_TE_TARGET_RC));
		244
		245	if(target_rc_s != NULL) {
		246	int target_rc = 0;
		247	crm_debug_2("Target rc: %s vs. %d", target_rc_s, rc);
		248	target_rc = crm_parse_int(target_rc_s, NULL);
		249	if(target_rc == rc) {
		250	crm_debug_2("Target rc: == %d", rc);
		251	if(status != LRM_OP_DONE) {
		252	crm_debug_2("Re-mapping op status to"
		253	" LRM_OP_DONE for rc=%d", rc);
		254	status = LRM_OP_DONE;
		255	}
		256	} else {
		257	crm_debug_2("Target rc: != %d", rc);
		258	if(status != LRM_OP_ERROR) {
		259	crm_info("Re-mapping op status to"
		260	" LRM_OP_ERROR for rc=%d", rc);
		261	status = LRM_OP_ERROR;
		262	}
		263	}
		264	}
		265
		266	/* 99 is the code we use for direct nack's */
		267	if(rc != 99 && status != LRM_OP_DONE) {
		268	const char task, uname;
		269	task = crm_element_value(action->xml, XML_LRM_ATTR_TASK);
		270	uname = crm_element_value(action->xml, XML_LRM_ATTR_TARGET);
		271	crm_warn("Action %s on %s failed (target: %s vs. rc: %d): %s",
		272	task, uname, target_rc_s, rc, op_status2text(status));
		273	}
		274
		275	return status;
246	}	276	}
247		277
248	/*	278	/*
Lines 255-263 match_graph_event( Link Here
255	match_graph_event(	285	match_graph_event(
256	crm_action_t action, crm_data_t event, const char *event_node)	286	crm_action_t action, crm_data_t event, const char *event_node)
257	{	287	{
258	int log_level_fail = LOG_ERR;
259	int target_rc = 0;
260	const char *target_rc_s = NULL;
261	const char *allow_fail = NULL;	288	const char *allow_fail = NULL;
262	const char *this_action = NULL;	289	const char *this_action = NULL;
263	const char *this_node = NULL;	290	const char *this_node = NULL;
Lines 296-310 match_graph_event( Link Here
296	crm_debug_2("Action %d : Node mismatch %s (%s) vs. %s",	323	crm_debug_2("Action %d : Node mismatch %s (%s) vs. %s",
297	action->id, this_node, this_uname, event_node);	324	action->id, this_node, this_uname, event_node);
298	return -1;	325	return -1;
299		326	}
300	}	327
301
302	crm_debug_2("Matched action (%d) %s", action->id, this_event);	328	crm_debug_2("Matched action (%d) %s", action->id, this_event);
303		329
304	CRM_CHECK(decode_transition_magic(	330	CRM_CHECK(decode_transition_magic(
305	magic, &update_te_uuid,	331	magic, &update_te_uuid,
306	&transition_i, &op_status_i, &op_rc_i), return -2);	332	&transition_i, &op_status_i, &op_rc_i), return -2);
307		333
		334	op_status_i = status_from_rc(action, op_status_i, op_rc_i);
		335	if(op_status_i != LRM_OP_DONE) {
		336	update_failcount(event, event_node, op_rc_i);
		337	}
		338
308	if(transition_i == -1) {	339	if(transition_i == -1) {
309	/* we never expect these - recompute */	340	/* we never expect these - recompute */
310	crm_err("Detected action %s initiated outside of a transition",	341	crm_err("Detected action %s initiated outside of a transition",
Lines 334-361 match_graph_event( Link Here
334	/* stop this event's timer if it had one */	365	/* stop this event's timer if it had one */
335	stop_te_timer(action->timer);	366	stop_te_timer(action->timer);
336	action->confirmed = TRUE;	367	action->confirmed = TRUE;
337
338	target_rc_s = g_hash_table_lookup(
339	action->params,crm_meta_name(XML_ATTR_TE_TARGET_RC));
340	if(target_rc_s != NULL) {
341	crm_debug_2("Target rc: %s vs. %d", target_rc_s, op_rc_i);
342	target_rc = crm_parse_int(target_rc_s, NULL);
343	if(target_rc == op_rc_i) {
344	crm_debug_2("Target rc: == %d", op_rc_i);
345	if(op_status_i != LRM_OP_DONE) {
346	crm_debug_2("Re-mapping op status to"
347	" LRM_OP_DONE for %s",update_event);
348	op_status_i = LRM_OP_DONE;
349	}
350	} else {
351	crm_debug_2("Target rc: != %d", op_rc_i);
352	if(op_status_i != LRM_OP_ERROR) {
353	crm_info("Re-mapping op status to"
354	" LRM_OP_ERROR for %s", update_event);
355	op_status_i = LRM_OP_ERROR;
356	}
357	}
358	}
359		368
360	/* Process OP status */	369	/* Process OP status */
361	switch(op_status_i) {	370	switch(op_status_i) {
Lines 371-388 match_graph_event( Link Here
371	case LRM_OP_DONE:	380	case LRM_OP_DONE:
372	break;	381	break;
373	case LRM_OP_ERROR:	382	case LRM_OP_ERROR:
374	/* This is the code we use for direct nack's */
375	if(op_rc_i == 99) {
376	log_level_fail = LOG_WARNING;
377	}
378	/* fall through */
379	case LRM_OP_TIMEOUT:	383	case LRM_OP_TIMEOUT:
380	case LRM_OP_NOTSUPPORTED:	384	case LRM_OP_NOTSUPPORTED:
381	action->failed = TRUE;	385	action->failed = TRUE;
382	crm_log_maybe(log_level_fail,
383	"Action %s on %s failed (target: %d vs. rc: %d): %s",
384	update_event, this_uname, target_rc,
385	op_rc_i, op_status2text(op_status_i));
386	break;	386	break;
387	case LRM_OP_CANCELLED:	387	case LRM_OP_CANCELLED:
388	/* do nothing?? */	388	/* do nothing?? */
Lines 405-414 match_graph_event( Link Here
405	}	405	}
406		406
407	if(action->failed) {	407	if(action->failed) {
408	/* ignore probes */
409	if(target_rc != EXECRA_NOT_RUNNING) {
410	update_failcount(action, op_rc_i);
411	}
412	abort_transition(action->synapse->priority+1,	408	abort_transition(action->synapse->priority+1,
413	tg_restart, "Event failed", event);	409	tg_restart, "Event failed", event);
414		410
Lines 544-549 process_graph_event(crm_data_t *event, c Link Here
544	/* unexpected event, trigger a pe-recompute */	540	/* unexpected event, trigger a pe-recompute */
545	/* possibly do this only for certain types of actions */	541	/* possibly do this only for certain types of actions */
546	crm_warn("Event not found.");	542	crm_warn("Event not found.");
		543	if(rc != EXECRA_OK) {
		544	update_failcount(event, event_node, rc);
		545	}
547	crm_log_xml_info(event, "match:not-found");	546	crm_log_xml_info(event, "match:not-found");
548	abort_transition(INFINITY, tg_restart, "Unexpected event", event);	547	abort_transition(INFINITY, tg_restart, "Unexpected event", event);
549	return;	548	return;