No OneTemporary
Actions

Size

89 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/include/crm/pengine/internal.h b/include/crm/pengine/internal.h
	index 38f1f4c8ea..8fd11cdd43 100644
	--- a/include/crm/pengine/internal.h
	+++ b/include/crm/pengine/internal.h
	@@ -1,434 +1,437 @@
	/*
	* Copyright 2004-2019 the Pacemaker project contributors
	*
	* The version control history for this file may have further details.
	*
	* This source code is licensed under the GNU Lesser General Public License
	* version 2.1 or later (LGPLv2.1+) WITHOUT ANY WARRANTY.
	*/

	#ifndef PE_INTERNAL__H
	# define PE_INTERNAL__H
	# include <string.h>
	# include <crm/pengine/status.h>
	# include <crm/pengine/remote_internal.h>
	# include <crm/common/output.h>

	# define pe_rsc_info(rsc, fmt, args...) crm_log_tag(LOG_INFO, rsc ? rsc->id : "<NULL>", fmt, ##args)
	# define pe_rsc_debug(rsc, fmt, args...) crm_log_tag(LOG_DEBUG, rsc ? rsc->id : "<NULL>", fmt, ##args)
	# define pe_rsc_trace(rsc, fmt, args...) crm_log_tag(LOG_TRACE, rsc ? rsc->id : "<NULL>", fmt, ##args)

	# define pe_err(fmt...) { was_processing_error = TRUE; crm_config_error = TRUE; crm_err(fmt); }
	# define pe_warn(fmt...) { was_processing_warning = TRUE; crm_config_warning = TRUE; crm_warn(fmt); }
	# define pe_proc_err(fmt...) { was_processing_error = TRUE; crm_err(fmt); }
	# define pe_proc_warn(fmt...) { was_processing_warning = TRUE; crm_warn(fmt); }
	# define pe_set_action_bit(action, bit) action->flags = crm_set_bit(__FUNCTION__, __LINE__, action->uuid, action->flags, bit)
	# define pe_clear_action_bit(action, bit) action->flags = crm_clear_bit(__FUNCTION__, __LINE__, action->uuid, action->flags, bit)

	typedef struct pe__location_constraint_s {
	char *id; // Constraint XML ID
	pe_resource_t *rsc_lh; // Resource being located
	enum rsc_role_e role_filter; // Role to locate
	enum pe_discover_e discover_mode; // Resource discovery
	GListPtr node_list_rh; // List of pe_node_t*
	} pe__location_t;

	typedef struct pe__order_constraint_s {
	int id;
	enum pe_ordering type;

	void *lh_opaque;
	resource_t *lh_rsc;
	action_t *lh_action;
	char *lh_action_task;

	void *rh_opaque;
	resource_t *rh_rsc;
	action_t *rh_action;
	char *rh_action_task;
	} pe__ordering_t;

	typedef struct notify_data_s {
	GSList *keys; // Environment variable name/value pairs

	const char *action;

	action_t *pre;
	action_t *post;
	action_t *pre_done;
	action_t *post_done;

	GListPtr active; /* notify_entry_t* */
	GListPtr inactive; /* notify_entry_t* */
	GListPtr start; /* notify_entry_t* */
	GListPtr stop; /* notify_entry_t* */
	GListPtr demote; /* notify_entry_t* */
	GListPtr promote; /* notify_entry_t* */
	GListPtr master; /* notify_entry_t* */
	GListPtr slave; /* notify_entry_t* */
	GHashTable *allowed_nodes;

	} notify_data_t;

	bool pe_can_fence(pe_working_set_t data_set, node_t node);

	int merge_weights(int w1, int w2);
	void add_hash_param(GHashTable * hash, const char name, const char value);

	char native_parameter(resource_t rsc, node_t * node, gboolean create, const char *name,
	pe_working_set_t * data_set);
	pe_node_t native_location(const pe_resource_t rsc, GList **list, int current);

	void pe_metadata(void);
	void verify_pe_options(GHashTable * options);

	void common_update_score(resource_t * rsc, const char *id, int score);
	void native_add_running(resource_t * rsc, node_t * node, pe_working_set_t * data_set);

	gboolean native_unpack(resource_t * rsc, pe_working_set_t * data_set);
	gboolean group_unpack(resource_t * rsc, pe_working_set_t * data_set);
	gboolean clone_unpack(resource_t * rsc, pe_working_set_t * data_set);
	gboolean pe__unpack_bundle(pe_resource_t rsc, pe_working_set_t data_set);

	resource_t native_find_rsc(resource_t rsc, const char id, const node_t node,
	int flags);

	gboolean native_active(resource_t * rsc, gboolean all);
	gboolean group_active(resource_t * rsc, gboolean all);
	gboolean clone_active(resource_t * rsc, gboolean all);
	gboolean pe__bundle_active(pe_resource_t *rsc, gboolean all);

	void native_print(resource_t * rsc, const char pre_text, long options, void print_data);
	void group_print(resource_t * rsc, const char pre_text, long options, void print_data);
	void clone_print(resource_t * rsc, const char pre_text, long options, void print_data);
	void pe__print_bundle(pe_resource_t rsc, const char pre_text, long options,
	void *print_data);

	int pe__name_and_nvpairs_xml(pcmk__output_t out, bool is_list, const char tag_name
	, size_t pairs_count, ...);
	char pe__node_display_name(node_t node, bool print_detail);

	int pe__ban_html(pcmk__output_t *out, va_list args);
	int pe__ban_text(pcmk__output_t *out, va_list args);
	int pe__ban_xml(pcmk__output_t *out, va_list args);
	int pe__clone_xml(pcmk__output_t *out, va_list args);
	int pe__clone_html(pcmk__output_t *out, va_list args);
	int pe__clone_text(pcmk__output_t *out, va_list args);
	int pe__cluster_counts_html(pcmk__output_t *out, va_list args);
	int pe__cluster_counts_text(pcmk__output_t *out, va_list args);
	int pe__cluster_counts_xml(pcmk__output_t *out, va_list args);
	int pe__cluster_dc_html(pcmk__output_t *out, va_list args);
	int pe__cluster_dc_text(pcmk__output_t *out, va_list args);
	int pe__cluster_dc_xml(pcmk__output_t *out, va_list args);
	int pe__cluster_options_html(pcmk__output_t *out, va_list args);
	int pe__cluster_options_text(pcmk__output_t *out, va_list args);
	int pe__cluster_options_xml(pcmk__output_t *out, va_list args);
	int pe__cluster_stack_html(pcmk__output_t *out, va_list args);
	int pe__cluster_stack_text(pcmk__output_t *out, va_list args);
	int pe__cluster_stack_xml(pcmk__output_t *out, va_list args);
	int pe__cluster_times_html(pcmk__output_t *out, va_list args);
	int pe__cluster_times_xml(pcmk__output_t *out, va_list args);
	int pe__cluster_times_text(pcmk__output_t *out, va_list args);
	int pe__failed_action_text(pcmk__output_t *out, va_list args);
	int pe__failed_action_xml(pcmk__output_t *out, va_list args);
	int pe__group_xml(pcmk__output_t *out, va_list args);
	int pe__group_html(pcmk__output_t *out, va_list args);
	int pe__group_text(pcmk__output_t *out, va_list args);
	int pe__bundle_xml(pcmk__output_t *out, va_list args);
	int pe__bundle_html(pcmk__output_t *out, va_list args);
	int pe__bundle_text(pcmk__output_t *out, va_list args);
	int pe__node_html(pcmk__output_t *out, va_list args);
	int pe__node_text(pcmk__output_t *out, va_list args);
	int pe__node_xml(pcmk__output_t *out, va_list args);
	int pe__node_attribute_html(pcmk__output_t *out, va_list args);
	int pe__node_attribute_text(pcmk__output_t *out, va_list args);
	int pe__node_attribute_xml(pcmk__output_t *out, va_list args);
	int pe__op_history_text(pcmk__output_t *out, va_list args);
	int pe__op_history_xml(pcmk__output_t *out, va_list args);
	int pe__resource_history_text(pcmk__output_t *out, va_list args);
	int pe__resource_history_xml(pcmk__output_t *out, va_list args);
	int pe__resource_xml(pcmk__output_t *out, va_list args);
	int pe__resource_html(pcmk__output_t *out, va_list args);
	int pe__resource_text(pcmk__output_t *out, va_list args);
	+int pe__ticket_html(pcmk__output_t *out, va_list args);
	+int pe__ticket_text(pcmk__output_t *out, va_list args);
	+int pe__ticket_xml(pcmk__output_t *out, va_list args);

	void native_free(resource_t * rsc);
	void group_free(resource_t * rsc);
	void clone_free(resource_t * rsc);
	void pe__free_bundle(pe_resource_t *rsc);

	enum rsc_role_e native_resource_state(const resource_t * rsc, gboolean current);
	enum rsc_role_e group_resource_state(const resource_t * rsc, gboolean current);
	enum rsc_role_e clone_resource_state(const resource_t * rsc, gboolean current);
	enum rsc_role_e pe__bundle_resource_state(const pe_resource_t *rsc,
	gboolean current);

	void pe__count_common(pe_resource_t *rsc);
	void pe__count_bundle(pe_resource_t *rsc);

	gboolean common_unpack(xmlNode * xml_obj, resource_t ** rsc, resource_t * parent,
	pe_working_set_t * data_set);
	void common_free(resource_t * rsc);

	extern node_t node_copy(const node_t this_node);
	extern time_t get_effective_time(pe_working_set_t * data_set);

	/* Failure handling utilities (from failcounts.c) */

	// bit flags for fail count handling options
	enum pe_fc_flags_e {
	pe_fc_default = 0x00,
	pe_fc_effective = 0x01, // don't count expired failures
	pe_fc_fillers = 0x02, // if container, include filler failures in count
	};

	int pe_get_failcount(node_t node, resource_t rsc, time_t *last_failure,
	uint32_t flags, xmlNode *xml_op,
	pe_working_set_t *data_set);

	pe_action_t pe__clear_failcount(pe_resource_t rsc, pe_node_t *node,
	const char *reason,
	pe_working_set_t *data_set);

	/* Functions for finding/counting a resource's active nodes */

	pe_node_t pe__find_active_on(const pe_resource_t rsc,
	unsigned int *count_all,
	unsigned int *count_clean);
	pe_node_t pe__find_active_requires(const pe_resource_t rsc,
	unsigned int *count);

	static inline pe_node_t *
	pe__current_node(const pe_resource_t *rsc)
	{
	return pe__find_active_on(rsc, NULL, NULL);
	}


	/* Binary like operators for lists of nodes */
	extern void node_list_exclude(GHashTable * list, GListPtr list2, gboolean merge_scores);
	extern GListPtr node_list_dup(GListPtr list, gboolean reset, gboolean filter);

	extern GHashTable *node_hash_from_list(GListPtr list);
	static inline gpointer
	pe_hash_table_lookup(GHashTable * hash, gconstpointer key)
	{
	if (hash) {
	return g_hash_table_lookup(hash, key);
	}
	return NULL;
	}

	extern action_t get_pseudo_op(const char name, pe_working_set_t * data_set);
	extern gboolean order_actions(action_t * lh_action, action_t * rh_action, enum pe_ordering order);

	GHashTable node_hash_dup(GHashTable hash);

	/* Printing functions for debug */
	extern void print_node(const char pre_text, node_t node, gboolean details);
	extern void print_str_str(gpointer key, gpointer value, gpointer user_data);
	extern void pe__output_node(node_t * node, gboolean details, pcmk__output_t *out);

	extern void dump_node_scores_worker(int level, const char file, const char function, int line,
	resource_t * rsc, const char comment, GHashTable nodes);

	extern void dump_node_capacity(int level, const char comment, node_t node);
	extern void dump_rsc_utilization(int level, const char comment, resource_t rsc, node_t * node);

	# define dump_node_scores(level, rsc, text, nodes) do { \
	dump_node_scores_worker(level, __FILE__, __FUNCTION__, __LINE__, rsc, text, nodes); \
	} while(0)

	/* Sorting functions */
	extern gint sort_rsc_priority(gconstpointer a, gconstpointer b);
	extern gint sort_rsc_index(gconstpointer a, gconstpointer b);

	extern xmlNode find_rsc_op_entry(resource_t rsc, const char *key);

	extern action_t custom_action(resource_t rsc, char key, const char task, node_t * on_node,
	gboolean optional, gboolean foo, pe_working_set_t * data_set);

	# define delete_key(rsc) generate_op_key(rsc->id, CRMD_ACTION_DELETE, 0)
	# define delete_action(rsc, node, optional) custom_action( \
	rsc, delete_key(rsc), CRMD_ACTION_DELETE, node, \
	optional, TRUE, data_set);

	# define stopped_key(rsc) generate_op_key(rsc->id, CRMD_ACTION_STOPPED, 0)
	# define stopped_action(rsc, node, optional) custom_action( \
	rsc, stopped_key(rsc), CRMD_ACTION_STOPPED, node, \
	optional, TRUE, data_set);

	# define stop_key(rsc) generate_op_key(rsc->id, CRMD_ACTION_STOP, 0)
	# define stop_action(rsc, node, optional) custom_action( \
	rsc, stop_key(rsc), CRMD_ACTION_STOP, node, \
	optional, TRUE, data_set);

	# define reload_key(rsc) generate_op_key(rsc->id, CRMD_ACTION_RELOAD, 0)
	# define start_key(rsc) generate_op_key(rsc->id, CRMD_ACTION_START, 0)
	# define start_action(rsc, node, optional) custom_action( \
	rsc, start_key(rsc), CRMD_ACTION_START, node, \
	optional, TRUE, data_set)

	# define started_key(rsc) generate_op_key(rsc->id, CRMD_ACTION_STARTED, 0)
	# define started_action(rsc, node, optional) custom_action( \
	rsc, started_key(rsc), CRMD_ACTION_STARTED, node, \
	optional, TRUE, data_set)

	# define promote_key(rsc) generate_op_key(rsc->id, CRMD_ACTION_PROMOTE, 0)
	# define promote_action(rsc, node, optional) custom_action( \
	rsc, promote_key(rsc), CRMD_ACTION_PROMOTE, node, \
	optional, TRUE, data_set)

	# define promoted_key(rsc) generate_op_key(rsc->id, CRMD_ACTION_PROMOTED, 0)
	# define promoted_action(rsc, node, optional) custom_action( \
	rsc, promoted_key(rsc), CRMD_ACTION_PROMOTED, node, \
	optional, TRUE, data_set)

	# define demote_key(rsc) generate_op_key(rsc->id, CRMD_ACTION_DEMOTE, 0)
	# define demote_action(rsc, node, optional) custom_action( \
	rsc, demote_key(rsc), CRMD_ACTION_DEMOTE, node, \
	optional, TRUE, data_set)

	# define demoted_key(rsc) generate_op_key(rsc->id, CRMD_ACTION_DEMOTED, 0)
	# define demoted_action(rsc, node, optional) custom_action( \
	rsc, demoted_key(rsc), CRMD_ACTION_DEMOTED, node, \
	optional, TRUE, data_set)

	extern int pe_get_configured_timeout(resource_t rsc, const char action,
	pe_working_set_t *data_set);

	extern action_t find_first_action(GListPtr input, const char uuid, const char *task,
	node_t * on_node);
	extern enum action_tasks get_complex_task(resource_t * rsc, const char *name,
	gboolean allow_non_atomic);

	extern GListPtr find_actions(GListPtr input, const char key, const node_t on_node);
	GList find_actions_exact(GList input, const char *key,
	const pe_node_t *on_node);
	extern GListPtr find_recurring_actions(GListPtr input, node_t * not_on_node);
	GList pe__resource_actions(const pe_resource_t rsc, const pe_node_t *node,
	const char *task, bool require_node);

	extern void pe_free_action(action_t * action);

	extern void resource_location(resource_t * rsc, node_t * node, int score, const char *tag,
	pe_working_set_t * data_set);

	extern gint sort_op_by_callid(gconstpointer a, gconstpointer b);
	extern gboolean get_target_role(resource_t * rsc, enum rsc_role_e *role);

	extern resource_t find_clone_instance(resource_t rsc, const char *sub_id,
	pe_working_set_t * data_set);

	extern void destroy_ticket(gpointer data);
	extern ticket_t ticket_new(const char ticket_id, pe_working_set_t * data_set);

	// Resources for manipulating resource names
	const char pe_base_name_end(const char id);
	char clone_strip(const char last_rsc_id);
	char clone_zero(const char last_rsc_id);

	static inline bool
	pe_base_name_eq(resource_t rsc, const char id)
	{
	if (id && rsc && rsc->id) {
	// Number of characters in rsc->id before any clone suffix
	size_t base_len = pe_base_name_end(rsc->id) - rsc->id + 1;

	return (strlen(id) == base_len) && !strncmp(id, rsc->id, base_len);
	}
	return FALSE;
	}

	int pe__target_rc_from_xml(xmlNode *xml_op);

	gint sort_node_uname(gconstpointer a, gconstpointer b);
	bool is_set_recursive(resource_t * rsc, long long flag, bool any);

	enum rsc_digest_cmp_val {
	/! Digests are the same /
	RSC_DIGEST_MATCH = 0,
	/! Params that require a restart changed /
	RSC_DIGEST_RESTART,
	/! Some parameter changed. /
	RSC_DIGEST_ALL,
	/*! rsc op didn't have a digest associated with it, so
	* it is unknown if parameters changed or not. */
	RSC_DIGEST_UNKNOWN,
	};

	typedef struct op_digest_cache_s {
	enum rsc_digest_cmp_val rc;
	xmlNode *params_all;
	xmlNode *params_secure;
	xmlNode *params_restart;
	char *digest_all_calc;
	char *digest_secure_calc;
	char *digest_restart_calc;
	} op_digest_cache_t;

	op_digest_cache_t rsc_action_digest_cmp(resource_t rsc, xmlNode * xml_op, node_t * node,
	pe_working_set_t * data_set);

	action_t pe_fence_op(node_t node, const char op, bool optional, const char reason, pe_working_set_t * data_set);
	void trigger_unfencing(
	resource_t * rsc, node_t node, const char reason, action_t dependency, pe_working_set_t data_set);

	void pe_action_set_reason(pe_action_t action, const char reason, bool overwrite);
	void pe_action_set_flag_reason(const char function, long line, pe_action_t action, pe_action_t reason, const char text, enum pe_action_flags flags, bool overwrite);

	#define pe_action_required(action, reason, text) pe_action_set_flag_reason(__FUNCTION__, __LINE__, action, reason, text, pe_action_optional, FALSE)
	#define pe_action_implies(action, reason, flag) pe_action_set_flag_reason(__FUNCTION__, __LINE__, action, reason, NULL, flag, FALSE)

	void set_bit_recursive(resource_t * rsc, unsigned long long flag);
	void clear_bit_recursive(resource_t * rsc, unsigned long long flag);

	gboolean add_tag_ref(GHashTable * tags, const char * tag_name, const char * obj_ref);

	void print_rscs_brief(GListPtr rsc_list, const char * pre_text, long options,
	void * print_data, gboolean print_all);
	void pe__rscs_brief_output(pcmk__output_t *out, GListPtr rsc_list, long options, gboolean print_all);
	void pe_fence_node(pe_working_set_t * data_set, node_t * node, const char *reason);

	node_t pe_create_node(const char id, const char uname, const char type,
	const char score, pe_working_set_t data_set);
	bool remote_id_conflict(const char remote_name, pe_working_set_t data);
	void common_print(resource_t * rsc, const char pre_text, const char name, node_t node, long options, void print_data);
	void pe__common_output_text(pcmk__output_t out, resource_t rsc, const char name, node_t node, long options);
	void pe__common_output_html(pcmk__output_t out, resource_t rsc, const char name, node_t node, long options);
	pe_resource_t pe__find_bundle_replica(const pe_resource_t bundle,
	const pe_node_t *node);
	bool pe__bundle_needs_remote_name(pe_resource_t *rsc);
	const char pe__add_bundle_remote_name(pe_resource_t rsc, xmlNode *xml,
	const char *field);
	const char pe_node_attribute_calculated(const pe_node_t node,
	const char *name,
	const resource_t *rsc);
	const char pe_node_attribute_raw(pe_node_t node, const char *name);
	bool pe__is_universal_clone(pe_resource_t *rsc,
	pe_working_set_t *data_set);
	void pe__add_param_check(xmlNode rsc_op, pe_resource_t rsc, pe_node_t *node,
	enum pe_check_parameters, pe_working_set_t *data_set);
	void pe__foreach_param_check(pe_working_set_t *data_set,
	void (cb)(pe_resource_t, pe_node_t, xmlNode,
	enum pe_check_parameters,
	pe_working_set_t*));
	void pe__free_param_checks(pe_working_set_t *data_set);

	bool pe__shutdown_requested(pe_node_t *node);
	void pe__update_recheck_time(time_t recheck, pe_working_set_t *data_set);

	#define BOOL2STR(x) ((x) ? "true" : "false")
	/*!
	* \internal
	* \brief Register xml formatting message functions.
	*/
	void pe__register_messages(pcmk__output_t *out);

	void pe__unpack_dataset_nvpairs(xmlNode xml_obj, const char set_name,
	GHashTable node_hash, GHashTable hash,
	const char *always_first, gboolean overwrite,
	pe_working_set_t *data_set);

	bool pe__resource_is_disabled(pe_resource_t *rsc);

	#endif
	diff --git a/lib/pengine/pe_output.c b/lib/pengine/pe_output.c
	index 62ea65bc53..1ca2c6c46b 100644
	--- a/lib/pengine/pe_output.c
	+++ b/lib/pengine/pe_output.c
	@@ -1,1304 +1,1304 @@
	/*
	* Copyright 2019 the Pacemaker project contributors
	*
	* The version control history for this file may have further details.
	*
	* This source code is licensed under the GNU Lesser General Public License
	* version 2.1 or later (LGPLv2.1+) WITHOUT ANY WARRANTY.
	*/

	#include <crm_internal.h>
	#include <crm/common/iso8601_internal.h>
	#include <crm/msg_xml.h>
	#include <crm/pengine/internal.h>

	#define s_if_plural(i) (((i) == 1)? "" : "s")

	static char *
	failed_action_string(xmlNodePtr xml_op) {
	const char *op_key = crm_element_value(xml_op, XML_LRM_ATTR_TASK_KEY);
	int rc = crm_parse_int(crm_element_value(xml_op, XML_LRM_ATTR_RC), "0");
	int status = crm_parse_int(crm_element_value(xml_op, XML_LRM_ATTR_OPSTATUS), "0");
	const char *exit_reason = crm_element_value(xml_op, XML_LRM_ATTR_EXIT_REASON);

	time_t last_change = 0;

	if (crm_element_value_epoch(xml_op, XML_RSC_OP_LAST_CHANGE,
	&last_change) == pcmk_ok) {
	crm_time_t *crm_when = crm_time_new(NULL);
	char *time_s = NULL;
	char *buf = NULL;

	crm_time_set_timet(crm_when, &last_change);
	time_s = crm_time_as_string(crm_when, crm_time_log_date \| crm_time_log_timeofday \| crm_time_log_with_timezone);

	buf = crm_strdup_printf("%s on %s '%s' (%d): call=%s, status='%s', exitreason='%s', last-rc-change='%s', queued=%sms, exec=%sms",
	op_key ? op_key : ID(xml_op),
	crm_element_value(xml_op, XML_ATTR_UNAME),
	services_ocf_exitcode_str(rc), rc,
	crm_element_value(xml_op, XML_LRM_ATTR_CALLID),
	services_lrm_status_str(status),
	exit_reason ? exit_reason : "none",
	time_s,
	crm_element_value(xml_op, XML_RSC_OP_T_QUEUE),
	crm_element_value(xml_op, XML_RSC_OP_T_EXEC));

	crm_time_free(crm_when);
	free(time_s);
	return buf;
	} else {
	return crm_strdup_printf("%s on %s '%s' (%d): call=%s, status=%s, exitreason='%s'",
	op_key ? op_key : ID(xml_op),
	crm_element_value(xml_op, XML_ATTR_UNAME),
	services_ocf_exitcode_str(rc), rc,
	crm_element_value(xml_op, XML_LRM_ATTR_CALLID),
	services_lrm_status_str(status),
	exit_reason ? exit_reason : "none");
	}
	}

	static char *
	last_changed_string(const char last_written, const char user,
	const char client, const char origin) {
	if (last_written != NULL \|\| user != NULL \|\| client != NULL \|\| origin != NULL) {
	return crm_strdup_printf("%s%s%s%s%s%s%s",
	last_written ? last_written : "",
	user ? " by " : "",
	user ? user : "",
	client ? " via " : "",
	client ? client : "",
	origin ? " on " : "",
	origin ? origin : "");
	} else {
	return strdup("");
	}
	}

	static char *
	op_history_string(xmlNode xml_op, const char task, const char *interval_ms_s,
	int rc, gboolean print_timing) {
	const char *call = crm_element_value(xml_op, XML_LRM_ATTR_CALLID);
	char *interval_str = NULL;
	char *buf = NULL;

	if (interval_ms_s && safe_str_neq(interval_ms_s, "0")) {
	char *pair = pcmk_format_nvpair("interval", interval_ms_s, "ms");
	interval_str = crm_strdup_printf(" %s", pair);
	free(pair);
	}

	if (print_timing) {
	char *last_change_str = NULL;
	char *last_run_str = NULL;
	char *exec_str = NULL;
	char *queue_str = NULL;

	const char *value = NULL;

	time_t epoch = 0;

	if ((crm_element_value_epoch(xml_op, XML_RSC_OP_LAST_CHANGE, &epoch) == pcmk_ok)
	&& (epoch > 0)) {
	char *time = pcmk_format_named_time(XML_RSC_OP_LAST_CHANGE, epoch);
	last_change_str = crm_strdup_printf(" %s", time);
	free(time);
	}

	if ((crm_element_value_epoch(xml_op, XML_RSC_OP_LAST_RUN, &epoch) == pcmk_ok)
	&& (epoch > 0)) {
	char *time = pcmk_format_named_time(XML_RSC_OP_LAST_RUN, epoch);
	last_run_str = crm_strdup_printf(" %s", time);
	free(time);
	}

	value = crm_element_value(xml_op, XML_RSC_OP_T_EXEC);
	if (value) {
	char *pair = pcmk_format_nvpair(XML_RSC_OP_T_EXEC, value, "ms");
	exec_str = crm_strdup_printf(" %s", pair);
	free(pair);
	}

	value = crm_element_value(xml_op, XML_RSC_OP_T_QUEUE);
	if (value) {
	char *pair = pcmk_format_nvpair(XML_RSC_OP_T_QUEUE, value, "ms");
	queue_str = crm_strdup_printf(" %s", pair);
	free(pair);
	}

	buf = crm_strdup_printf("(%s) %s:%s%s%s%s%s rc=%d (%s)", call, task,
	interval_str ? interval_str : "",
	last_change_str ? last_change_str : "",
	last_run_str ? last_run_str : "",
	exec_str ? exec_str : "",
	queue_str ? queue_str : "",
	rc, services_ocf_exitcode_str(rc));

	if (last_change_str) {
	free(last_change_str);
	}

	if (last_run_str) {
	free(last_run_str);
	}

	if (exec_str) {
	free(exec_str);
	}

	if (queue_str) {
	free(queue_str);
	}
	} else {
	buf = crm_strdup_printf("(%s) %s:%s", call, task,
	interval_str ? interval_str : "");
	}

	if (interval_str) {
	free(interval_str);
	}

	return buf;
	}

	static char *
	resource_history_string(resource_t rsc, const char rsc_id, gboolean all,
	int failcount, time_t last_failure) {
	char *buf = NULL;

	if (rsc == NULL) {
	buf = crm_strdup_printf("%s: orphan", rsc_id);
	} else if (all \|\| failcount \|\| last_failure > 0) {
	char *failcount_s = failcount > 0 ? crm_strdup_printf(" %s=%d", CRM_FAIL_COUNT_PREFIX, failcount) : strdup("");
	char *lastfail_s = last_failure > 0 ? crm_strdup_printf(" %s=%s", CRM_LAST_FAILURE_PREFIX,
	crm_now_string(&last_failure)) : strdup("");

	buf = crm_strdup_printf("%s: migration-threshold=%d%s%s",
	rsc_id, rsc->migration_threshold, failcount_s, lastfail_s);
	free(failcount_s);
	free(lastfail_s);
	} else {
	buf = crm_strdup_printf("%s:", rsc_id);
	}

	return buf;
	}

	char *
	pe__node_display_name(node_t *node, bool print_detail)
	{
	char *node_name;
	const char *node_host = NULL;
	const char *node_id = NULL;
	int name_len;

	CRM_ASSERT((node != NULL) && (node->details != NULL) && (node->details->uname != NULL));

	/* Host is displayed only if this is a guest node */
	if (pe__is_guest_node(node)) {
	node_t *host_node = pe__current_node(node->details->remote_rsc);

	if (host_node && host_node->details) {
	node_host = host_node->details->uname;
	}
	if (node_host == NULL) {
	node_host = ""; /* so we at least get "uname@" to indicate guest */
	}
	}

	/* Node ID is displayed if different from uname and detail is requested */
	if (print_detail && safe_str_neq(node->details->uname, node->details->id)) {
	node_id = node->details->id;
	}

	/* Determine name length */
	name_len = strlen(node->details->uname) + 1;
	if (node_host) {
	name_len += strlen(node_host) + 1; /* "@node_host" */
	}
	if (node_id) {
	name_len += strlen(node_id) + 3; /* + " (node_id)" */
	}

	/* Allocate and populate display name */
	node_name = malloc(name_len);
	CRM_ASSERT(node_name != NULL);
	strcpy(node_name, node->details->uname);
	if (node_host) {
	strcat(node_name, "@");
	strcat(node_name, node_host);
	}
	if (node_id) {
	strcat(node_name, " (");
	strcat(node_name, node_id);
	strcat(node_name, ")");
	}
	return node_name;
	}

	int
	pe__name_and_nvpairs_xml(pcmk__output_t out, bool is_list, const char tag_name
	, size_t pairs_count, ...)
	{
	xmlNodePtr xml_node = NULL;
	va_list args;

	CRM_ASSERT(tag_name != NULL);

	xml_node = pcmk__output_xml_peek_parent(out);
	CRM_ASSERT(xml_node != NULL);
	xml_node = is_list
	? create_xml_node(xml_node, tag_name)
	: xmlNewChild(xml_node, NULL, (pcmkXmlStr) tag_name, NULL);

	va_start(args, pairs_count);
	while(pairs_count--) {
	const char param_name = va_arg(args, const char );
	const char param_value = va_arg(args, const char );
	if (param_name && param_value) {
	xmlSetProp(xml_node, (pcmkXmlStr)param_name, (pcmkXmlStr)param_value);
	}
	};
	va_end(args);

	if (is_list) {
	pcmk__output_xml_push_parent(out, xml_node);
	}
	return 0;
	}

	int
	pe__ban_html(pcmk__output_t *out, va_list args) {
	pe_node_t pe_node = va_arg(args, pe_node_t );
	pe__location_t location = va_arg(args, pe__location_t );
	gboolean print_clone_detail = va_arg(args, gboolean);

	char *node_name = pe__node_display_name(pe_node, print_clone_detail);
	char *buf = crm_strdup_printf("%s\tprevents %s from running %son %s",
	location->id, location->rsc_lh->id,
	location->role_filter == RSC_ROLE_MASTER ? "as Master " : "",
	node_name);

	pcmk__output_create_html_node(out, "li", NULL, NULL, buf);

	free(node_name);
	free(buf);
	return 0;
	}

	int
	pe__ban_text(pcmk__output_t *out, va_list args) {
	pe_node_t pe_node = va_arg(args, pe_node_t );
	pe__location_t location = va_arg(args, pe__location_t );
	gboolean print_clone_detail = va_arg(args, gboolean);

	char *node_name = pe__node_display_name(pe_node, print_clone_detail);
	out->list_item(out, NULL, "%s\tprevents %s from running %son %s",
	location->id, location->rsc_lh->id,
	location->role_filter == RSC_ROLE_MASTER ? "as Master " : "",
	node_name);

	free(node_name);
	return 0;
	}

	int
	pe__ban_xml(pcmk__output_t *out, va_list args) {
	xmlNodePtr node = pcmk__output_create_xml_node(out, "ban");
	pe_node_t pe_node = va_arg(args, pe_node_t );
	pe__location_t location = va_arg(args, pe__location_t );

	char *weight_s = crm_itoa(pe_node->weight);

	xmlSetProp(node, (pcmkXmlStr) "id", (pcmkXmlStr) location->id);
	xmlSetProp(node, (pcmkXmlStr) "resource", (pcmkXmlStr) location->rsc_lh->id);
	xmlSetProp(node, (pcmkXmlStr) "node", (pcmkXmlStr) pe_node->details->uname);
	xmlSetProp(node, (pcmkXmlStr) "weight", (pcmkXmlStr) weight_s);
	xmlSetProp(node, (pcmkXmlStr) "master_only",
	(pcmkXmlStr) (location->role_filter == RSC_ROLE_MASTER ? "true" : "false"));

	free(weight_s);
	return 0;
	}

	int
	pe__cluster_counts_html(pcmk__output_t *out, va_list args) {
	xmlNodePtr nodes_node = pcmk__output_create_xml_node(out, "li");
	xmlNodePtr resources_node = pcmk__output_create_xml_node(out, "li");

	unsigned int nnodes = va_arg(args, unsigned int);
	unsigned int nresources = va_arg(args, unsigned int);
	unsigned int ndisabled = va_arg(args, unsigned int);
	unsigned int nblocked = va_arg(args, unsigned int);

	char *nnodes_str = crm_strdup_printf("%d node%s configured", nnodes, s_if_plural(nnodes));

	pcmk_create_html_node(nodes_node, "span", NULL, NULL, nnodes_str);
	free(nnodes_str);

	if (ndisabled && nblocked) {
	char *s = crm_strdup_printf("%d resource instance%s configured (%d ",
	nresources, s_if_plural(nresources),
	ndisabled);
	pcmk_create_html_node(resources_node, "span", NULL, NULL, s);
	free(s);

	pcmk_create_html_node(resources_node, "span", NULL, "bold", "DISABLED");

	s = crm_strdup_printf(", %d ", nblocked);
	pcmk_create_html_node(resources_node, "span", NULL, NULL, s);
	free(s);

	pcmk_create_html_node(resources_node, "span", NULL, "bold", "BLOCKED");
	pcmk_create_html_node(resources_node, "span", NULL, NULL,
	" from further action due to failure)");
	} else if (ndisabled && !nblocked) {
	char *s = crm_strdup_printf("%d resource instance%s configured (%d ",
	nresources, s_if_plural(nresources),
	ndisabled);
	pcmk_create_html_node(resources_node, "span", NULL, NULL, s);
	free(s);

	pcmk_create_html_node(resources_node, "span", NULL, "bold", "DISABLED");
	pcmk_create_html_node(resources_node, "span", NULL, NULL, ")");
	} else if (!ndisabled && nblocked) {
	char *s = crm_strdup_printf("%d resource instance%s configured (%d ",
	nresources, s_if_plural(nresources),
	nblocked);
	pcmk_create_html_node(resources_node, "span", NULL, NULL, s);
	free(s);

	pcmk_create_html_node(resources_node, "span", NULL, "bold", "BLOCKED");
	pcmk_create_html_node(resources_node, "span", NULL, NULL,
	" from further action due to failure)");
	} else {
	char *s = crm_strdup_printf("%d resource instance%s configured",
	nresources, s_if_plural(nresources));
	pcmk_create_html_node(resources_node, "span", NULL, NULL, s);
	free(s);
	}

	return 0;
	}

	int
	pe__cluster_counts_text(pcmk__output_t *out, va_list args) {
	unsigned int nnodes = va_arg(args, unsigned int);
	unsigned int nresources = va_arg(args, unsigned int);
	unsigned int ndisabled = va_arg(args, unsigned int);
	unsigned int nblocked = va_arg(args, unsigned int);

	out->list_item(out, NULL, "%d node%s configured", nnodes, s_if_plural(nnodes));

	if (ndisabled && nblocked) {
	out->list_item(out, NULL, "%d resource instance%s configured "
	"(%d DISABLED, %d BLOCKED from "
	"further action due to failure)",
	nresources, s_if_plural(nresources), ndisabled,
	nblocked);
	} else if (ndisabled && !nblocked) {
	out->list_item(out, NULL, "%d resource instance%s configured "
	"(%d DISABLED)",
	nresources, s_if_plural(nresources), ndisabled);
	} else if (!ndisabled && nblocked) {
	out->list_item(out, NULL, "%d resource instance%s configured "
	"(%d BLOCKED from further action "
	"due to failure)",
	nresources, s_if_plural(nresources), nblocked);
	} else {
	out->list_item(out, NULL, "%d resource instance%s configured",
	nresources, s_if_plural(nresources));
	}

	return 0;
	}

	int
	pe__cluster_counts_xml(pcmk__output_t *out, va_list args) {
	xmlNodePtr nodes_node = pcmk__output_create_xml_node(out, "nodes_configured");
	xmlNodePtr resources_node = pcmk__output_create_xml_node(out, "resources_configured");

	unsigned int nnodes = va_arg(args, unsigned int);
	unsigned int nresources = va_arg(args, unsigned int);
	unsigned int ndisabled = va_arg(args, unsigned int);
	unsigned int nblocked = va_arg(args, unsigned int);

	char *s = crm_itoa(nnodes);
	xmlSetProp(nodes_node, (pcmkXmlStr) "number", (pcmkXmlStr) s);
	free(s);

	s = crm_itoa(nresources);
	xmlSetProp(resources_node, (pcmkXmlStr) "number", (pcmkXmlStr) s);
	free(s);

	s = crm_itoa(ndisabled);
	xmlSetProp(resources_node, (pcmkXmlStr) "disabled", (pcmkXmlStr) s);
	free(s);

	s = crm_itoa(nblocked);
	xmlSetProp(resources_node, (pcmkXmlStr) "blocked", (pcmkXmlStr) s);
	free(s);

	return 0;
	}

	int
	pe__cluster_dc_html(pcmk__output_t *out, va_list args) {
	xmlNodePtr node = pcmk__output_create_xml_node(out, "li");

	node_t dc = va_arg(args, node_t );
	const char quorum = va_arg(args, const char );
	const char dc_version_s = va_arg(args, const char );
	const char dc_name = va_arg(args, const char );

	pcmk_create_html_node(node, "span", NULL, "bold", "Current DC: ");

	if (dc) {
	if (crm_is_true(quorum)) {
	char *buf = crm_strdup_printf("%s (version %s) - partition with quorum",
	dc_name, dc_version_s ? dc_version_s : "unknown");
	pcmk_create_html_node(node, "span", NULL, NULL, buf);
	free(buf);
	} else {
	char *buf = crm_strdup_printf("%s (version %s) - partition",
	dc_name, dc_version_s ? dc_version_s : "unknown");
	pcmk_create_html_node(node, "span", NULL, NULL, buf);
	free(buf);

	pcmk_create_html_node(node, "span", NULL, "warning", "WITHOUT");
	pcmk_create_html_node(node, "span", NULL, NULL, "quorum");
	}
	} else {
	pcmk_create_html_node(node ,"span", NULL, "warning", "NONE");
	}

	return 0;
	}

	int
	pe__cluster_dc_text(pcmk__output_t *out, va_list args) {
	node_t dc = va_arg(args, node_t );
	const char quorum = va_arg(args, const char );
	const char dc_version_s = va_arg(args, const char );
	const char dc_name = va_arg(args, const char );

	if (dc) {
	out->list_item(out, "Current DC", "%s (version %s) - partition %s quorum",
	dc_name, dc_version_s ? dc_version_s : "unknown",
	crm_is_true(quorum) ? "with" : "WITHOUT");
	} else {
	out->list_item(out, "Current DC", "NONE");
	}

	return 0;
	}

	int
	pe__cluster_dc_xml(pcmk__output_t *out, va_list args) {
	xmlNodePtr node = pcmk__output_create_xml_node(out, "current_dc");

	node_t dc = va_arg(args, node_t );
	const char quorum = va_arg(args, const char );
	const char dc_version_s = va_arg(args, const char );

	if (dc) {
	xmlSetProp(node, (pcmkXmlStr) "present", (pcmkXmlStr) "true");
	xmlSetProp(node, (pcmkXmlStr) "version", (pcmkXmlStr) (dc_version_s ? dc_version_s : ""));
	xmlSetProp(node, (pcmkXmlStr) "name", (pcmkXmlStr) dc->details->uname);
	xmlSetProp(node, (pcmkXmlStr) "id", (pcmkXmlStr) dc->details->id);
	xmlSetProp(node, (pcmkXmlStr) "with_quorum", (pcmkXmlStr) (crm_is_true(quorum) ? "true" : "false"));
	} else {
	xmlSetProp(node, (pcmkXmlStr) "present", (pcmkXmlStr) "false");
	}

	return 0;
	}

	int
	pe__cluster_options_html(pcmk__output_t *out, va_list args) {
	pe_working_set_t data_set = va_arg(args, pe_working_set_t );

	out->list_item(out, NULL, "STONITH of failed nodes %s",
	is_set(data_set->flags, pe_flag_stonith_enabled) ? "enabled" : "disabled");

	out->list_item(out, NULL, "Cluster is %s",
	is_set(data_set->flags, pe_flag_symmetric_cluster) ? "symmetric" : "asymmetric");

	switch (data_set->no_quorum_policy) {
	case no_quorum_freeze:
	out->list_item(out, NULL, "No Quorum policy: Freeze resources");
	break;

	case no_quorum_stop:
	out->list_item(out, NULL, "No Quorum policy: Stop ALL resources");
	break;

	case no_quorum_ignore:
	out->list_item(out, NULL, "No Quorum policy: Ignore");
	break;

	case no_quorum_suicide:
	out->list_item(out, NULL, "No Quorum policy: Suicide");
	break;
	}

	if (is_set(data_set->flags, pe_flag_maintenance_mode)) {
	xmlNodePtr node = pcmk__output_create_xml_node(out, "li");

	pcmk_create_html_node(node, "span", NULL, "bold", "DISABLED");
	pcmk_create_html_node(node, "span", NULL, NULL,
	" (the cluster will not attempt to start, stop, or recover services)");
	} else {
	out->list_item(out, NULL, "Resource management enabled");
	}

	return 0;
	}

	int
	pe__cluster_options_text(pcmk__output_t *out, va_list args) {
	pe_working_set_t data_set = va_arg(args, pe_working_set_t );

	if (is_set(data_set->flags, pe_flag_maintenance_mode)) {
	fprintf(out->dest, "\n * Resource management is DISABLED *");
	fprintf(out->dest, "\n The cluster will not attempt to start, stop or recover services");
	fprintf(out->dest, "\n");
	}

	return 0;
	}

	int
	pe__cluster_options_xml(pcmk__output_t *out, va_list args) {
	xmlNodePtr node = pcmk__output_create_xml_node(out, "cluster_options");
	pe_working_set_t data_set = va_arg(args, pe_working_set_t );

	xmlSetProp(node, (pcmkXmlStr) "stonith-enabled",
	(pcmkXmlStr) (is_set(data_set->flags, pe_flag_stonith_enabled) ? "true" : "false"));
	xmlSetProp(node, (pcmkXmlStr) "symmetric-cluster",
	(pcmkXmlStr) (is_set(data_set->flags, pe_flag_symmetric_cluster) ? "true" : "false"));

	switch (data_set->no_quorum_policy) {
	case no_quorum_freeze:
	xmlSetProp(node, (pcmkXmlStr) "no-quorum-policy", (pcmkXmlStr) "freeze");
	break;

	case no_quorum_stop:
	xmlSetProp(node, (pcmkXmlStr) "no-quorum-policy", (pcmkXmlStr) "stop");
	break;

	case no_quorum_ignore:
	xmlSetProp(node, (pcmkXmlStr) "no-quorum-policy", (pcmkXmlStr) "ignore");
	break;

	case no_quorum_suicide:
	xmlSetProp(node, (pcmkXmlStr) "no-quorum-policy", (pcmkXmlStr) "suicide");
	break;
	}

	xmlSetProp(node, (pcmkXmlStr) "maintenance-mode",
	(pcmkXmlStr) (is_set(data_set->flags, pe_flag_maintenance_mode) ? "true" : "false"));

	return 0;
	}

	int
	pe__cluster_stack_html(pcmk__output_t *out, va_list args) {
	xmlNodePtr node = pcmk__output_create_xml_node(out, "li");
	const char stack_s = va_arg(args, const char );

	pcmk_create_html_node(node, "span", NULL, "bold", "Stack: ");
	pcmk_create_html_node(node, "span", NULL, NULL, stack_s);

	return 0;
	}

	int
	pe__cluster_stack_text(pcmk__output_t *out, va_list args) {
	const char stack_s = va_arg(args, const char );
	out->list_item(out, "Stack", "%s", stack_s);
	return 0;
	}

	int
	pe__cluster_stack_xml(pcmk__output_t *out, va_list args) {
	xmlNodePtr node = pcmk__output_create_xml_node(out, "stack");
	const char stack_s = va_arg(args, const char );

	xmlSetProp(node, (pcmkXmlStr) "type", (pcmkXmlStr) stack_s);

	return 0;
	}

	int
	pe__cluster_times_html(pcmk__output_t *out, va_list args) {
	xmlNodePtr updated_node = pcmk__output_create_xml_node(out, "li");
	xmlNodePtr changed_node = pcmk__output_create_xml_node(out, "li");

	const char last_written = va_arg(args, const char );
	const char user = va_arg(args, const char );
	const char client = va_arg(args, const char );
	const char origin = va_arg(args, const char );

	char *buf = last_changed_string(last_written, user, client, origin);

	pcmk_create_html_node(updated_node, "span", NULL, "bold", "Last updated: ");
	pcmk_create_html_node(updated_node, "span", NULL, NULL, crm_now_string(NULL));

	pcmk_create_html_node(changed_node, "span", NULL, "bold", "Last change: ");
	pcmk_create_html_node(changed_node, "span", NULL, NULL, buf);

	free(buf);
	return 0;
	}

	int
	pe__cluster_times_xml(pcmk__output_t *out, va_list args) {
	xmlNodePtr updated_node = pcmk__output_create_xml_node(out, "last_update");
	xmlNodePtr changed_node = pcmk__output_create_xml_node(out, "last_change");

	const char last_written = va_arg(args, const char );
	const char user = va_arg(args, const char );
	const char client = va_arg(args, const char );
	const char origin = va_arg(args, const char );

	xmlSetProp(updated_node, (pcmkXmlStr) "time", (pcmkXmlStr) crm_now_string(NULL));

	xmlSetProp(changed_node, (pcmkXmlStr) "time", (pcmkXmlStr) (last_written ? last_written : ""));
	xmlSetProp(changed_node, (pcmkXmlStr) "user", (pcmkXmlStr) (user ? user : ""));
	xmlSetProp(changed_node, (pcmkXmlStr) "client", (pcmkXmlStr) (client ? client : ""));
	xmlSetProp(changed_node, (pcmkXmlStr) "origin", (pcmkXmlStr) (origin ? origin : ""));

	return 0;
	}

	int
	pe__cluster_times_text(pcmk__output_t *out, va_list args) {
	const char last_written = va_arg(args, const char );
	const char user = va_arg(args, const char );
	const char client = va_arg(args, const char );
	const char origin = va_arg(args, const char );

	char *buf = last_changed_string(last_written, user, client, origin);

	out->list_item(out, "Last updated", "%s", crm_now_string(NULL));
	out->list_item(out, "Last change", " %s", buf);

	free(buf);
	return 0;
	}

	int
	pe__failed_action_text(pcmk__output_t *out, va_list args) {
	xmlNodePtr xml_op = va_arg(args, xmlNodePtr);
	char *s = failed_action_string(xml_op);

	out->list_item(out, NULL, "%s", s);
	free(s);
	return 0;
	}

	int
	pe__failed_action_xml(pcmk__output_t *out, va_list args) {
	xmlNodePtr xml_op = va_arg(args, xmlNodePtr);

	const char *op_key = crm_element_value(xml_op, XML_LRM_ATTR_TASK_KEY);
	const char *last = crm_element_value(xml_op, XML_RSC_OP_LAST_CHANGE);
	int rc = crm_parse_int(crm_element_value(xml_op, XML_LRM_ATTR_RC), "0");
	int status = crm_parse_int(crm_element_value(xml_op, XML_LRM_ATTR_OPSTATUS), "0");
	const char *exit_reason = crm_element_value(xml_op, XML_LRM_ATTR_EXIT_REASON);

	char *rc_s = crm_itoa(rc);
	char *reason_s = crm_xml_escape(exit_reason ? exit_reason : "none");
	xmlNodePtr node = pcmk__output_create_xml_node(out, "failure");

	xmlSetProp(node, (pcmkXmlStr) (op_key ? "op_key" : "id"),
	(pcmkXmlStr) (op_key ? op_key : "id"));
	xmlSetProp(node, (pcmkXmlStr) "node",
	(pcmkXmlStr) crm_element_value(xml_op, XML_ATTR_UNAME));
	xmlSetProp(node, (pcmkXmlStr) "exitstatus",
	(pcmkXmlStr) services_ocf_exitcode_str(rc));
	xmlSetProp(node, (pcmkXmlStr) "exitreason", (pcmkXmlStr) reason_s);
	xmlSetProp(node, (pcmkXmlStr) "exitcode", (pcmkXmlStr) rc_s);
	xmlSetProp(node, (pcmkXmlStr) "call",
	(pcmkXmlStr) crm_element_value(xml_op, XML_LRM_ATTR_CALLID));
	xmlSetProp(node, (pcmkXmlStr) "status",
	(pcmkXmlStr) services_lrm_status_str(status));

	if (last) {
	char *s = crm_itoa(crm_parse_ms(crm_element_value(xml_op, XML_LRM_ATTR_INTERVAL_MS)));
	time_t when = crm_parse_int(last, "0");
	crm_time_t *crm_when = crm_time_new(NULL);
	char *rc_change = NULL;

	crm_time_set_timet(crm_when, &when);
	rc_change = crm_time_as_string(crm_when, crm_time_log_date \| crm_time_log_timeofday \| crm_time_log_with_timezone);

	xmlSetProp(node, (pcmkXmlStr) "last-rc-change", (pcmkXmlStr) rc_change);
	xmlSetProp(node, (pcmkXmlStr) "queued",
	(pcmkXmlStr) crm_element_value(xml_op, XML_RSC_OP_T_QUEUE));
	xmlSetProp(node, (pcmkXmlStr) "exec",
	(pcmkXmlStr) crm_element_value(xml_op, XML_RSC_OP_T_EXEC));
	xmlSetProp(node, (pcmkXmlStr) "interval", (pcmkXmlStr) s);
	xmlSetProp(node, (pcmkXmlStr) "task",
	(pcmkXmlStr) crm_element_value(xml_op, XML_LRM_ATTR_TASK));

	free(s);
	free(rc_change);
	crm_time_free(crm_when);
	}

	free(reason_s);
	free(rc_s);
	return 0;
	}

	int
	pe__node_html(pcmk__output_t *out, va_list args) {
	node_t node = va_arg(args, node_t );
	unsigned int print_opts = va_arg(args, unsigned int);
	gboolean full = va_arg(args, gboolean);
	const char node_mode G_GNUC_UNUSED = va_arg(args, const char );
	gboolean print_clone_detail = va_arg(args, gboolean);
	gboolean print_brief = va_arg(args, gboolean);
	gboolean group_by_node = va_arg(args, gboolean);

	char *node_name = pe__node_display_name(node, print_clone_detail);
	char *buf = crm_strdup_printf("Node: %s", node_name);

	if (full) {
	xmlNodePtr item_node = pcmk__output_create_xml_node(out, "li");

	pcmk_create_html_node(item_node, "span", NULL, NULL, buf);

	if (node->details->standby_onfail && node->details->online) {
	pcmk_create_html_node(item_node, "span", NULL, "standby", " standby (on-fail)");
	} else if (node->details->standby && node->details->online) {
	char *s = crm_strdup_printf(" standby%s", node->details->running_rsc ? " (with active resources)" : "");
	pcmk_create_html_node(item_node, "span", NULL, " standby", s);
	free(s);
	} else if (node->details->standby) {
	pcmk_create_html_node(item_node, "span", NULL, "offline", " OFFLINE (standby)");
	} else if (node->details->maintenance && node->details->online) {
	pcmk_create_html_node(item_node, "span", NULL, "maint", " maintenance");
	} else if (node->details->maintenance) {
	pcmk_create_html_node(item_node, "span", NULL, "offline", " OFFLINE (maintenance)");
	} else if (node->details->online) {
	pcmk_create_html_node(item_node, "span", NULL, "online", " online");
	} else {
	pcmk_create_html_node(item_node, "span", NULL, "offline", " OFFLINE");
	}
	if (print_brief && group_by_node) {
	out->begin_list(out, NULL, NULL, NULL);
	pe__rscs_brief_output(out, node->details->running_rsc, print_opts \| pe_print_rsconly,
	FALSE);
	out->end_list(out);

	} else if (group_by_node) {
	GListPtr lpc2 = NULL;

	out->begin_list(out, NULL, NULL, NULL);
	for (lpc2 = node->details->running_rsc; lpc2 != NULL; lpc2 = lpc2->next) {
	resource_t rsc = (resource_t ) lpc2->data;
	out->message(out, crm_map_element_name(rsc->xml), print_opts \| pe_print_rsconly, rsc);
	}
	out->end_list(out);
	}
	} else {
	out->begin_list(out, NULL, NULL, "%s", buf);
	}

	free(buf);
	free(node_name);
	return 0;
	}

	int
	pe__node_text(pcmk__output_t *out, va_list args) {
	node_t node = va_arg(args, node_t );
	unsigned int print_opts = va_arg(args, unsigned int);
	gboolean full = va_arg(args, gboolean);
	const char node_mode = va_arg(args, const char );
	gboolean print_clone_detail = va_arg(args, gboolean);
	gboolean print_brief = va_arg(args, gboolean);
	gboolean group_by_node = va_arg(args, gboolean);

	if (full) {
	char *node_name = pe__node_display_name(node, print_clone_detail);
	char *buf = NULL;

	/* Print the node name and status */
	if (pe__is_guest_node(node)) {
	buf = crm_strdup_printf("GuestNode %s: %s", node_name, node_mode);
	} else if (pe__is_remote_node(node)) {
	buf = crm_strdup_printf("RemoteNode %s: %s", node_name, node_mode);
	} else {
	buf = crm_strdup_printf("Node %s: %s", node_name, node_mode);
	}

	/* If we're grouping by node, print its resources */
	if (group_by_node) {
	out->begin_list(out, NULL, NULL, "%s", buf);
	out->begin_list(out, NULL, NULL, "Resources");

	if (print_brief) {
	pe__rscs_brief_output(out, node->details->running_rsc,
	print_opts \| pe_print_rsconly, FALSE);
	} else {
	GListPtr gIter2 = NULL;

	for (gIter2 = node->details->running_rsc; gIter2 != NULL; gIter2 = gIter2->next) {
	resource_t rsc = (resource_t ) gIter2->data;
	out->message(out, crm_map_element_name(rsc->xml), print_opts \| pe_print_rsconly, rsc);
	}
	}

	out->end_list(out);
	out->end_list(out);
	} else {
	out->list_item(out, NULL, "%s", buf);
	}

	free(buf);
	free(node_name);
	} else {
	out->begin_list(out, NULL, NULL, "Node: %s", pe__node_display_name(node, print_clone_detail));
	}

	return 0;
	}

	int
	pe__node_xml(pcmk__output_t *out, va_list args) {
	node_t node = va_arg(args, node_t );
	unsigned int print_opts = va_arg(args, unsigned int);
	gboolean full = va_arg(args, gboolean);
	const char node_mode G_GNUC_UNUSED = va_arg(args, const char );
	gboolean print_clone_detail G_GNUC_UNUSED = va_arg(args, gboolean);
	gboolean print_brief G_GNUC_UNUSED = va_arg(args, gboolean);
	gboolean group_by_node = va_arg(args, gboolean);

	if (full) {
	const char *node_type = "unknown";
	char *length_s = crm_itoa(g_list_length(node->details->running_rsc));

	switch (node->details->type) {
	case node_member:
	node_type = "member";
	break;
	case node_remote:
	node_type = "remote";
	break;
	case node_ping:
	node_type = "ping";
	break;
	}
	pe__name_and_nvpairs_xml(out, true, "node", 13,
	"name", node->details->uname,
	"id", node->details->id,
	"online", node->details->online ? "true" : "false",
	"standby", node->details->standby ? "true" : "false",
	"standby_onfail", node->details->standby_onfail ? "true" : "false",
	"maintenance", node->details->maintenance ? "true" : "false",
	"pending", node->details->pending ? "true" : "false",
	"unclean", node->details->unclean ? "true" : "false",
	"shutdown", node->details->shutdown ? "true" : "false",
	"expected_up", node->details->expected_up ? "true" : "false",
	"is_dc", node->details->is_dc ? "true" : "false",
	"resources_running", length_s,
	"type", node_type);

	if (pe__is_guest_node(node)) {
	xmlNodePtr xml_node = pcmk__output_xml_peek_parent(out);
	xmlSetProp(xml_node, (pcmkXmlStr) "id_as_resource",
	(pcmkXmlStr) node->details->remote_rsc->container->id);
	}

	if (group_by_node) {
	GListPtr lpc = NULL;

	for (lpc = node->details->running_rsc; lpc != NULL; lpc = lpc->next) {
	resource_t rsc = (resource_t ) lpc->data;
	out->message(out, crm_map_element_name(rsc->xml), print_opts \| pe_print_rsconly, rsc);
	}
	}

	free(length_s);

	out->end_list(out);
	} else {
	xmlNodePtr parent = pcmk__output_xml_create_parent(out, "node");
	xmlSetProp(parent, (pcmkXmlStr) "name", (pcmkXmlStr) node->details->uname);
	}

	return 0;
	}

	int
	pe__node_attribute_text(pcmk__output_t *out, va_list args) {
	const char name = va_arg(args, const char );
	const char value = va_arg(args, const char );
	gboolean add_extra = va_arg(args, gboolean);
	int expected_score = va_arg(args, int);


	if (add_extra) {
	int v = crm_parse_int(value, "0");

	if (v <= 0) {
	out->list_item(out, NULL, "%-32s\t: %-10s\t: Connectivity is lost", name, value);
	} else if (v < expected_score) {
	out->list_item(out, NULL, "%-32s\t: %-10s\t: Connectivity is degraded (Expected=%d)", name, value, expected_score);
	} else {
	out->list_item(out, NULL, "%-32s\t: %-10s", name, value);
	}
	} else {
	out->list_item(out, NULL, "%-32s\t: %-10s", name, value);
	}

	return 0;
	}

	int
	pe__node_attribute_html(pcmk__output_t *out, va_list args) {
	const char name = va_arg(args, const char );
	const char value = va_arg(args, const char );
	gboolean add_extra = va_arg(args, gboolean);
	int expected_score = va_arg(args, int);

	if (add_extra) {
	int v = crm_parse_int(value, "0");
	char *s = crm_strdup_printf("%s: %s", name, value);
	xmlNodePtr item_node = pcmk__output_create_xml_node(out, "li");

	pcmk_create_html_node(item_node, "span", NULL, NULL, s);
	free(s);

	if (v <= 0) {
	pcmk_create_html_node(item_node, "span", NULL, "bold", "(connectivity is lost)");
	} else if (v < expected_score) {
	char *buf = crm_strdup_printf("(connectivity is degraded -- expected %d", expected_score);
	pcmk_create_html_node(item_node, "span", NULL, "bold", buf);
	free(buf);
	}
	} else {
	out->list_item(out, NULL, "%s: %s", name, value);
	}

	return 0;
	}

	int
	pe__node_attribute_xml(pcmk__output_t *out, va_list args) {
	const char name = va_arg(args, const char );
	const char value = va_arg(args, const char );
	gboolean add_extra = va_arg(args, gboolean);
	int expected_score = va_arg(args, int);

	xmlNodePtr node = pcmk__output_create_xml_node(out, "attribute");
	xmlSetProp(node, (pcmkXmlStr) "name", (pcmkXmlStr) name);
	xmlSetProp(node, (pcmkXmlStr) "value", (pcmkXmlStr) value);

	if (add_extra) {
	char *buf = crm_itoa(expected_score);
	xmlSetProp(node, (pcmkXmlStr) "expected", (pcmkXmlStr) buf);
	free(buf);
	}

	return 0;
	}

	int
	pe__op_history_text(pcmk__output_t *out, va_list args) {
	xmlNode xml_op = va_arg(args, xmlNode );
	const char task = va_arg(args, const char );
	const char interval_ms_s = va_arg(args, const char );
	int rc = va_arg(args, int);
	gboolean print_timing = va_arg(args, gboolean);

	char *buf = op_history_string(xml_op, task, interval_ms_s, rc, print_timing);

	out->list_item(out, NULL, "%s", buf);

	free(buf);
	return 0;
	}

	int
	pe__op_history_xml(pcmk__output_t *out, va_list args) {
	xmlNode xml_op = va_arg(args, xmlNode );
	const char task = va_arg(args, const char );
	const char interval_ms_s = va_arg(args, const char );
	int rc = va_arg(args, int);
	gboolean print_timing = va_arg(args, gboolean);

	char *rc_s = NULL;

	xmlNodePtr node = pcmk__output_create_xml_node(out, "operation_history");

	xmlSetProp(node, (pcmkXmlStr) "call",
	(pcmkXmlStr) crm_element_value(xml_op, XML_LRM_ATTR_CALLID));
	xmlSetProp(node, (pcmkXmlStr) "task", (pcmkXmlStr) task);

	if (interval_ms_s && safe_str_neq(interval_ms_s, "0")) {
	char *s = crm_strdup_printf("%sms", interval_ms_s);
	xmlSetProp(node, (pcmkXmlStr) "interval", (pcmkXmlStr) s);
	free(s);
	}

	if (print_timing) {
	const char *value = NULL;

	value = crm_element_value(xml_op, XML_RSC_OP_LAST_CHANGE);
	if (value) {
	time_t int_value = (time_t) crm_parse_int(value, NULL);
	if (int_value > 0) {
	xmlSetProp(node, (pcmkXmlStr) XML_RSC_OP_LAST_CHANGE,
	(pcmkXmlStr) crm_now_string(&int_value));
	}
	}

	value = crm_element_value(xml_op, XML_RSC_OP_LAST_RUN);
	if (value) {
	time_t int_value = (time_t) crm_parse_int(value, NULL);
	if (int_value > 0) {
	xmlSetProp(node, (pcmkXmlStr) XML_RSC_OP_LAST_RUN,
	(pcmkXmlStr) crm_now_string(&int_value));
	}
	}

	value = crm_element_value(xml_op, XML_RSC_OP_T_EXEC);
	if (value) {
	char *s = crm_strdup_printf("%sms", value);
	xmlSetProp(node, (pcmkXmlStr) XML_RSC_OP_T_EXEC, (pcmkXmlStr) s);
	free(s);
	}
	value = crm_element_value(xml_op, XML_RSC_OP_T_QUEUE);
	if (value) {
	char *s = crm_strdup_printf("%sms", value);
	xmlSetProp(node, (pcmkXmlStr) XML_RSC_OP_T_QUEUE, (pcmkXmlStr) s);
	free(s);
	}
	}

	rc_s = crm_itoa(rc);
	xmlSetProp(node, (pcmkXmlStr) "rc", (pcmkXmlStr) rc_s);
	xmlSetProp(node, (pcmkXmlStr) "rc_text", (pcmkXmlStr) services_ocf_exitcode_str(rc));
	free(rc_s);
	return 0;
	}

	int
	pe__resource_history_text(pcmk__output_t *out, va_list args) {
	resource_t rsc = va_arg(args, resource_t );
	const char rsc_id = va_arg(args, const char );
	gboolean all = va_arg(args, gboolean);
	int failcount = va_arg(args, int);
	time_t last_failure = va_arg(args, int);

	char *buf = resource_history_string(rsc, rsc_id, all, failcount, last_failure);

	out->begin_list(out, NULL, NULL, "%s", buf);
	free(buf);
	return 0;
	}

	int
	pe__resource_history_xml(pcmk__output_t *out, va_list args) {
	resource_t rsc = va_arg(args, resource_t );
	const char rsc_id = va_arg(args, const char );
	gboolean all = va_arg(args, gboolean);
	int failcount = va_arg(args, int);
	time_t last_failure = va_arg(args, int);

	xmlNodePtr node = pcmk__output_xml_create_parent(out, "resource_history");
	xmlSetProp(node, (pcmkXmlStr) "id", (pcmkXmlStr) rsc_id);

	if (rsc == NULL) {
	xmlSetProp(node, (pcmkXmlStr) "orphan", (pcmkXmlStr) "true");
	} else if (all \|\| failcount \|\| last_failure > 0) {
	char *migration_s = crm_itoa(rsc->migration_threshold);

	xmlSetProp(node, (pcmkXmlStr) "orphan", (pcmkXmlStr) "false");
	xmlSetProp(node, (pcmkXmlStr) "migration-threshold",
	(pcmkXmlStr) migration_s);
	free(migration_s);

	if (failcount > 0) {
	char *s = crm_itoa(failcount);
	xmlSetProp(node, (pcmkXmlStr) CRM_FAIL_COUNT_PREFIX, (pcmkXmlStr) s);
	free(s);
	}

	if (last_failure > 0) {
	xmlSetProp(node, (pcmkXmlStr) CRM_LAST_FAILURE_PREFIX,
	(pcmkXmlStr) crm_now_string(&last_failure));
	}
	}

	return 0;
	}

	-static int
	+int
	pe__ticket_html(pcmk__output_t *out, va_list args) {
	ticket_t ticket = va_arg(args, ticket_t );

	if (ticket->last_granted > -1) {
	char *time = pcmk_format_named_time("last-granted", ticket->last_granted);
	out->list_item(out, NULL, "%s:\t%s%s %s", ticket->id,
	ticket->granted ? "granted" : "revoked",
	ticket->standby ? " [standby]" : "",
	time);
	free(time);
	} else {
	out->list_item(out, NULL, "%s:\t%s%s", ticket->id,
	ticket->granted ? "granted" : "revoked",
	ticket->standby ? " [standby]" : "");
	}

	return 0;
	}

	-static int
	+int
	pe__ticket_text(pcmk__output_t *out, va_list args) {
	ticket_t ticket = va_arg(args, ticket_t );

	if (ticket->last_granted > -1) {
	char *time = pcmk_format_named_time("last-granted", ticket->last_granted);
	out->list_item(out, ticket->id, "\t%s%s %s",
	ticket->granted ? "granted" : "revoked",
	ticket->standby ? " [standby]" : "",
	time);
	free(time);
	} else {
	out->list_item(out, ticket->id, "\t%s%s",
	ticket->granted ? "granted" : "revoked",
	ticket->standby ? " [standby]" : "");
	}

	return 0;
	}

	-static int
	+int
	pe__ticket_xml(pcmk__output_t *out, va_list args) {
	xmlNodePtr node = NULL;

	ticket_t ticket = va_arg(args, ticket_t );

	node = pcmk__output_create_xml_node(out, "ticket");
	xmlSetProp(node, (pcmkXmlStr) "id", (pcmkXmlStr) ticket->id);
	xmlSetProp(node, (pcmkXmlStr) "status", (pcmkXmlStr) (ticket->granted ? "granted" : "revoked"));
	xmlSetProp(node, (pcmkXmlStr) "standby", (pcmkXmlStr) (ticket->standby ? "true" : "false"));

	if (ticket->last_granted > -1) {
	xmlSetProp(node, (pcmkXmlStr) "last-granted",
	(pcmkXmlStr) crm_now_string(&ticket->last_granted));
	}

	return 0;
	}

	static pcmk__message_entry_t fmt_functions[] = {
	{ "ban", "html", pe__ban_html },
	{ "ban", "log", pe__ban_text },
	{ "ban", "text", pe__ban_text },
	{ "ban", "xml", pe__ban_xml },
	{ "bundle", "xml", pe__bundle_xml },
	{ "bundle", "html", pe__bundle_html },
	{ "bundle", "text", pe__bundle_text },
	{ "bundle", "log", pe__bundle_text },
	{ "clone", "xml", pe__clone_xml },
	{ "clone", "html", pe__clone_html },
	{ "clone", "text", pe__clone_text },
	{ "clone", "log", pe__clone_text },
	{ "cluster-counts", "html", pe__cluster_counts_html },
	{ "cluster-counts", "log", pe__cluster_counts_text },
	{ "cluster-counts", "text", pe__cluster_counts_text },
	{ "cluster-counts", "xml", pe__cluster_counts_xml },
	{ "cluster-dc", "html", pe__cluster_dc_html },
	{ "cluster-dc", "log", pe__cluster_dc_text },
	{ "cluster-dc", "text", pe__cluster_dc_text },
	{ "cluster-dc", "xml", pe__cluster_dc_xml },
	{ "cluster-options", "html", pe__cluster_options_html },
	{ "cluster-options", "log", pe__cluster_options_text },
	{ "cluster-options", "text", pe__cluster_options_text },
	{ "cluster-options", "xml", pe__cluster_options_xml },
	{ "cluster-stack", "html", pe__cluster_stack_html },
	{ "cluster-stack", "log", pe__cluster_stack_text },
	{ "cluster-stack", "text", pe__cluster_stack_text },
	{ "cluster-stack", "xml", pe__cluster_stack_xml },
	{ "cluster-times", "html", pe__cluster_times_html },
	{ "cluster-times", "log", pe__cluster_times_text },
	{ "cluster-times", "text", pe__cluster_times_text },
	{ "cluster-times", "xml", pe__cluster_times_xml },
	{ "failed-action", "html", pe__failed_action_text },
	{ "failed-action", "log", pe__failed_action_text },
	{ "failed-action", "text", pe__failed_action_text },
	{ "failed-action", "xml", pe__failed_action_xml },
	{ "group", "xml", pe__group_xml },
	{ "group", "html", pe__group_html },
	{ "group", "text", pe__group_text },
	{ "group", "log", pe__group_text },
	{ "node", "html", pe__node_html },
	{ "node", "log", pe__node_text },
	{ "node", "text", pe__node_text },
	{ "node", "xml", pe__node_xml },
	{ "node-attribute", "html", pe__node_attribute_html },
	{ "node-attribute", "log", pe__node_attribute_text },
	{ "node-attribute", "text", pe__node_attribute_text },
	{ "node-attribute", "xml", pe__node_attribute_xml },
	{ "op-history", "html", pe__op_history_text },
	{ "op-history", "log", pe__op_history_text },
	{ "op-history", "text", pe__op_history_text },
	{ "op-history", "xml", pe__op_history_xml },
	{ "primitive", "xml", pe__resource_xml },
	{ "primitive", "html", pe__resource_html },
	{ "primitive", "text", pe__resource_text },
	{ "primitive", "log", pe__resource_text },
	{ "resource-history", "html", pe__resource_history_text },
	{ "resource-history", "log", pe__resource_history_text },
	{ "resource-history", "text", pe__resource_history_text },
	{ "resource-history", "xml", pe__resource_history_xml },
	{ "ticket", "html", pe__ticket_html },
	{ "ticket", "text", pe__ticket_text },
	{ "ticket", "xml", pe__ticket_xml },

	{ NULL, NULL, NULL }
	};

	void
	pe__register_messages(pcmk__output_t *out) {
	pcmk__register_messages(out, fmt_functions);
	}

	void
	pe__output_node(node_t node, gboolean details, pcmk__output_t out)
	{
	if (node == NULL) {
	crm_trace("<NULL>");
	return;
	}

	CRM_ASSERT(node->details);
	crm_trace("%sNode %s: (weight=%d, fixed=%s)",
	node->details->online ? "" : "Unavailable/Unclean ",
	node->details->uname, node->weight, node->fixed ? "True" : "False");

	if (details) {
	char *pe_mutable = strdup("\t\t");
	GListPtr gIter = node->details->running_rsc;

	crm_trace("\t\t===Node Attributes");
	g_hash_table_foreach(node->details->attrs, print_str_str, pe_mutable);
	free(pe_mutable);

	crm_trace("\t\t=== Resources");

	for (; gIter != NULL; gIter = gIter->next) {
	resource_t rsc = (resource_t ) gIter->data;

	// @TODO pe_print_log probably doesn't belong here
	out->message(out, crm_map_element_name(rsc->xml),
	pe_print_log\|pe_print_pending, rsc);
	}
	}
	}
	diff --git a/tools/Makefile.am b/tools/Makefile.am
	index 62b3bc0359..65a4e10df4 100644
	--- a/tools/Makefile.am
	+++ b/tools/Makefile.am
	@@ -1,159 +1,159 @@
	#
	# Copyright 2004-2019 the Pacemaker project contributors
	#
	# The version control history for this file may have further details.
	#
	# This source code is licensed under the GNU General Public License version 2
	# or later (GPLv2+) WITHOUT ANY WARRANTY.
	#
	include $(top_srcdir)/Makefile.common

	if BUILD_SYSTEMD
	systemdsystemunit_DATA = crm_mon.service
	endif

	noinst_HEADERS = crm_mon.h crm_resource.h

	pcmkdir = $(datadir)/$(PACKAGE)
	pcmk_DATA = report.common report.collector

	sbin_SCRIPTS = crm_report crm_standby crm_master crm_failcount
	if BUILD_CIBSECRETS
	sbin_SCRIPTS += cibsecret
	endif
	noinst_SCRIPTS = pcmk_simtimes

	EXTRA_DIST = crm_diff.8.inc \
	crm_mon.sysconfig \
	crm_mon.8.inc \
	crm_node.8.inc \
	stonith_admin.8.inc

	sbin_PROGRAMS = attrd_updater \
	cibadmin \
	crmadmin \
	crm_simulate \
	crm_attribute \
	crm_diff \
	crm_error \
	crm_mon \
	crm_node \
	crm_resource \
	crm_rule \
	crm_shadow \
	crm_verify \
	crm_ticket \
	iso8601 \
	stonith_admin

	if BUILD_SERVICELOG
	sbin_PROGRAMS += notifyServicelogEvent
	endif
	if BUILD_OPENIPMI_SERVICELOG
	sbin_PROGRAMS += ipmiservicelogd
	endif

	## SOURCES

	# A few tools are just thin wrappers around crm_attribute.
	# This makes their help get updated when crm_attribute changes
	# (see Makefile.common).
	MAN8DEPS = crm_attribute

	crmadmin_SOURCES = crmadmin.c
	crmadmin_LDADD = $(top_builddir)/lib/pengine/libpe_status.la \
	$(top_builddir)/lib/cib/libcib.la \
	$(top_builddir)/lib/common/libcrmcommon.la

	crm_error_SOURCES = crm_error.c
	crm_error_LDADD = $(top_builddir)/lib/common/libcrmcommon.la

	cibadmin_SOURCES = cibadmin.c
	cibadmin_LDADD = $(top_builddir)/lib/cib/libcib.la \
	$(top_builddir)/lib/common/libcrmcommon.la

	crm_shadow_SOURCES = crm_shadow.c
	crm_shadow_LDADD = $(top_builddir)/lib/cib/libcib.la \
	$(top_builddir)/lib/common/libcrmcommon.la

	crm_node_SOURCES = crm_node.c
	crm_node_LDADD = $(top_builddir)/lib/cib/libcib.la \
	$(top_builddir)/lib/common/libcrmcommon.la

	crm_simulate_SOURCES = crm_simulate.c

	crm_simulate_LDADD = $(top_builddir)/lib/pengine/libpe_status.la \
	$(top_builddir)/lib/pacemaker/libpacemaker.la \
	$(top_builddir)/lib/cib/libcib.la \
	$(top_builddir)/lib/common/libcrmcommon.la

	crm_diff_SOURCES = crm_diff.c
	crm_diff_LDADD = $(top_builddir)/lib/common/libcrmcommon.la

	-crm_mon_SOURCES = crm_mon.c crm_mon_curses.c crm_mon_output.c crm_mon_print.c crm_mon_runtime.c crm_mon_xml.c
	+crm_mon_SOURCES = crm_mon.c crm_mon_curses.c crm_mon_print.c crm_mon_runtime.c crm_mon_xml.c
	crm_mon_LDADD = $(top_builddir)/lib/pengine/libpe_status.la \
	$(top_builddir)/lib/fencing/libstonithd.la \
	$(top_builddir)/lib/pacemaker/libpacemaker.la \
	$(top_builddir)/lib/cib/libcib.la \
	$(top_builddir)/lib/common/libcrmcommon.la \
	$(CURSESLIBS)

	crm_verify_SOURCES = crm_verify.c
	crm_verify_LDADD = $(top_builddir)/lib/pengine/libpe_status.la \
	$(top_builddir)/lib/pacemaker/libpacemaker.la \
	$(top_builddir)/lib/cib/libcib.la \
	$(top_builddir)/lib/common/libcrmcommon.la

	crm_attribute_SOURCES = crm_attribute.c
	crm_attribute_LDADD = $(top_builddir)/lib/cluster/libcrmcluster.la \
	$(top_builddir)/lib/cib/libcib.la \
	$(top_builddir)/lib/common/libcrmcommon.la

	crm_resource_SOURCES = crm_resource.c crm_resource_ban.c crm_resource_runtime.c crm_resource_print.c
	crm_resource_LDADD = $(top_builddir)/lib/pengine/libpe_rules.la \
	$(top_builddir)/lib/fencing/libstonithd.la \
	$(top_builddir)/lib/lrmd/liblrmd.la \
	$(top_builddir)/lib/services/libcrmservice.la \
	$(top_builddir)/lib/pengine/libpe_status.la \
	$(top_builddir)/lib/pacemaker/libpacemaker.la \
	$(top_builddir)/lib/cib/libcib.la \
	$(top_builddir)/lib/common/libcrmcommon.la

	crm_rule_SOURCES = crm_rule.c
	crm_rule_LDADD = $(top_builddir)/lib/cib/libcib.la \
	$(top_builddir)/lib/pengine/libpe_rules.la \
	$(top_builddir)/lib/pengine/libpe_status.la \
	$(top_builddir)/lib/common/libcrmcommon.la

	iso8601_SOURCES = iso8601.c
	iso8601_LDADD = $(top_builddir)/lib/common/libcrmcommon.la

	attrd_updater_SOURCES = attrd_updater.c
	attrd_updater_LDADD = $(top_builddir)/lib/common/libcrmcommon.la

	crm_ticket_SOURCES = crm_ticket.c
	crm_ticket_LDADD = $(top_builddir)/lib/pengine/libpe_rules.la \
	$(top_builddir)/lib/pengine/libpe_status.la \
	$(top_builddir)/lib/pacemaker/libpacemaker.la \
	$(top_builddir)/lib/cib/libcib.la \
	$(top_builddir)/lib/common/libcrmcommon.la

	stonith_admin_SOURCES = stonith_admin.c
	stonith_admin_LDADD = $(top_builddir)/lib/common/libcrmcommon.la \
	$(top_builddir)/lib/cib/libcib.la \
	$(top_builddir)/lib/pengine/libpe_status.la \
	$(top_builddir)/lib/fencing/libstonithd.la

	if BUILD_SERVICELOG
	notifyServicelogEvent_SOURCES = notifyServicelogEvent.c
	notifyServicelogEvent_CFLAGS = $(SERVICELOG_CFLAGS)
	notifyServicelogEvent_LDADD = $(top_builddir)/lib/common/libcrmcommon.la $(SERVICELOG_LIBS)
	endif

	if BUILD_OPENIPMI_SERVICELOG
	ipmiservicelogd_SOURCES = ipmiservicelogd.c
	ipmiservicelogd_CFLAGS = $(OPENIPMI_SERVICELOG_CFLAGS) $(SERVICELOG_CFLAGS)
	ipmiservicelogd_LDFLAGS = $(top_builddir)/lib/common/libcrmcommon.la $(OPENIPMI_SERVICELOG_LIBS) $(SERVICELOG_LIBS)
	endif

	CLEANFILES = $(man8_MANS)
	diff --git a/tools/crm_mon_curses.c b/tools/crm_mon_curses.c
	index 549c8d50bf..5742d1913b 100644
	--- a/tools/crm_mon_curses.c
	+++ b/tools/crm_mon_curses.c
	@@ -1,304 +1,380 @@
	/*
	* Copyright 2019 the Pacemaker project contributors
	*
	* The version control history for this file may have further details.
	*
	* This source code is licensed under the GNU Lesser General Public License
	* version 2.1 or later (LGPLv2.1+) WITHOUT ANY WARRANTY.
	*/

	#include <stdarg.h>
	#include <stdlib.h>
	#include <crm/crm.h>
	#include <crm/common/curses_internal.h>
	#include <crm/common/output.h>
	+#include <crm/pengine/internal.h>
	#include <glib.h>

	#include "crm_mon.h"

	#if CURSES_ENABLED

	GOptionEntry crm_mon_curses_output_entries[] = {
	{ NULL }
	};

	typedef struct curses_list_data_s {
	unsigned int len;
	char *singular_noun;
	char *plural_noun;
	} curses_list_data_t;

	typedef struct private_data_s {
	GQueue *parent_q;
	} private_data_t;

	static void
	curses_free_priv(pcmk__output_t *out) {
	private_data_t *priv = out->priv;

	if (priv == NULL) {
	return;
	}

	g_queue_free(priv->parent_q);
	free(priv);
	}

	static bool
	curses_init(pcmk__output_t *out) {
	private_data_t *priv = NULL;

	/* If curses_init was previously called on this output struct, just return. */
	if (out->priv != NULL) {
	return true;
	} else {
	out->priv = calloc(1, sizeof(private_data_t));
	if (out->priv == NULL) {
	return false;
	}

	priv = out->priv;
	}

	priv->parent_q = g_queue_new();

	initscr();
	cbreak();
	noecho();

	return true;
	}

	static void
	curses_finish(pcmk__output_t out, crm_exit_t exit_status, bool print, void *copy_dest) {
	}

	static void
	curses_reset(pcmk__output_t *out) {
	CRM_ASSERT(out->priv != NULL);

	curses_free_priv(out);
	curses_init(out);
	}

	static void
	curses_subprocess_output(pcmk__output_t *out, int exit_status,
	const char proc_stdout, const char proc_stderr) {
	if (proc_stdout != NULL) {
	printw("%s\n", proc_stdout);
	}

	if (proc_stderr != NULL) {
	printw("%s\n", proc_stderr);
	}

	clrtoeol();
	refresh();
	}

	/* curses_version is defined in curses.h, so we can't use that name here.
	* Note that this function prints out via text, not with curses.
	*/
	static void
	curses_ver(pcmk__output_t *out, bool extended) {
	if (extended) {
	printf("Pacemaker %s (Build: %s): %s\n", PACEMAKER_VERSION, BUILD_VERSION, CRM_FEATURES);
	} else {
	printf("Pacemaker %s\n", PACEMAKER_VERSION);
	printf("Written by Andrew Beekhof\n");
	}
	}

	G_GNUC_PRINTF(2, 3)
	static void
	curses_err_info(pcmk__output_t out, const char format, ...) {
	va_list ap;

	/* Informational output does not get indented, to separate it from other
	* potentially indented list output.
	*/
	va_start(ap, format);
	vw_printw(stdscr, format, ap);
	va_end(ap);

	/* Add a newline. */
	addch('\n');

	clrtoeol();
	refresh();
	}

	static void
	curses_output_xml(pcmk__output_t out, const char name, const char *buf) {
	private_data_t *priv = out->priv;

	CRM_ASSERT(priv != NULL);
	curses_indented_printf(out, "%s", buf);
	}

	G_GNUC_PRINTF(4, 5)
	static void
	curses_begin_list(pcmk__output_t out, const char singular_noun, const char *plural_noun,
	const char *format, ...) {
	private_data_t *priv = out->priv;
	curses_list_data_t *new_list = NULL;
	va_list ap;

	CRM_ASSERT(priv != NULL);

	va_start(ap, format);

	curses_indented_vprintf(out, format, ap);
	printw(":\n");

	va_end(ap);

	new_list = calloc(1, sizeof(curses_list_data_t));
	new_list->len = 0;
	new_list->singular_noun = singular_noun == NULL ? NULL : strdup(singular_noun);
	new_list->plural_noun = plural_noun == NULL ? NULL : strdup(plural_noun);

	g_queue_push_tail(priv->parent_q, new_list);
	}

	G_GNUC_PRINTF(3, 4)
	static void
	curses_list_item(pcmk__output_t out, const char id, const char *format, ...) {
	private_data_t *priv = out->priv;
	va_list ap;

	CRM_ASSERT(priv != NULL);

	va_start(ap, format);

	if (id != NULL) {
	curses_indented_printf(out, "%s: ", id);
	vw_printw(stdscr, format, ap);
	} else {
	curses_indented_vprintf(out, format, ap);
	}

	addch('\n');
	va_end(ap);

	out->increment_list(out);
	}

	static void
	curses_increment_list(pcmk__output_t *out) {
	private_data_t *priv = out->priv;
	gpointer tail;

	CRM_ASSERT(priv != NULL);
	tail = g_queue_peek_tail(priv->parent_q);
	CRM_ASSERT(tail != NULL);
	((curses_list_data_t *) tail)->len++;
	}

	static void
	curses_end_list(pcmk__output_t *out) {
	private_data_t *priv = out->priv;
	curses_list_data_t *node = NULL;

	CRM_ASSERT(priv != NULL);
	node = g_queue_pop_tail(priv->parent_q);

	if (node->singular_noun != NULL && node->plural_noun != NULL) {
	if (node->len == 1) {
	curses_indented_printf(out, "%d %s found\n", node->len, node->singular_noun);
	} else {
	curses_indented_printf(out, "%d %s found\n", node->len, node->plural_noun);
	}
	}

	free(node);
	}

	pcmk__output_t *
	crm_mon_mk_curses_output(char **argv) {
	pcmk__output_t *retval = calloc(1, sizeof(pcmk__output_t));

	if (retval == NULL) {
	return NULL;
	}

	retval->fmt_name = "console";
	retval->request = g_strjoinv(" ", argv);
	retval->supports_quiet = true;

	retval->init = curses_init;
	retval->free_priv = curses_free_priv;
	retval->finish = curses_finish;
	retval->reset = curses_reset;

	retval->register_message = pcmk__register_message;
	retval->message = pcmk__call_message;

	retval->subprocess_output = curses_subprocess_output;
	retval->version = curses_ver;
	retval->err = curses_err_info;
	retval->info = curses_err_info;
	retval->output_xml = curses_output_xml;

	retval->begin_list = curses_begin_list;
	retval->list_item = curses_list_item;
	retval->increment_list = curses_increment_list;
	retval->end_list = curses_end_list;

	return retval;
	}

	G_GNUC_PRINTF(2, 0)
	void
	curses_indented_vprintf(pcmk__output_t out, const char format, va_list args) {
	int level = 0;
	private_data_t *priv = out->priv;

	CRM_ASSERT(priv != NULL);

	level = g_queue_get_length(priv->parent_q);

	for (int i = 0; i < level; i++) {
	printw(" ");
	}

	if (level > 0) {
	printw("* ");
	}

	vw_printw(stdscr, format, args);

	clrtoeol();
	refresh();
	}

	G_GNUC_PRINTF(2, 3)
	void
	curses_indented_printf(pcmk__output_t out, const char format, ...) {
	va_list ap;

	va_start(ap, format);
	curses_indented_vprintf(out, format, ap);
	va_end(ap);
	}
	+
	+static int
	+stonith_event_console(pcmk__output_t *out, va_list args) {
	+ stonith_history_t event = va_arg(args, stonith_history_t );
	+ int full_history = va_arg(args, int);
	+ gboolean later_succeeded = va_arg(args, gboolean);
	+
	+ crm_time_t *crm_when = crm_time_new(NULL);
	+ char *buf = NULL;
	+
	+ crm_time_set_timet(crm_when, &(event->completed));
	+ buf = crm_time_as_string(crm_when, crm_time_log_date \| crm_time_log_timeofday \| crm_time_log_with_timezone);
	+
	+ switch (event->state) {
	+ case st_failed:
	+ curses_indented_printf(out, "%s of %s failed: delegate=%s, client=%s, origin=%s, %s='%s %s'\n",
	+ stonith_action_str(event->action), event->target,
	+ event->delegate ? event->delegate : "",
	+ event->client, event->origin,
	+ full_history ? "completed" : "last-failed", buf,
	+ later_succeeded ? "(a later attempt succeeded)" : "");
	+ break;
	+
	+ case st_done:
	+ curses_indented_printf(out, "%s of %s successful: delegate=%s, client=%s, origin=%s, %s='%s'\n",
	+ stonith_action_str(event->action), event->target,
	+ event->delegate ? event->delegate : "",
	+ event->client, event->origin,
	+ full_history ? "completed" : "last-successful", buf);
	+ break;
	+
	+ default:
	+ curses_indented_printf(out, "%s of %s pending: client=%s, origin=%s\n",
	+ stonith_action_str(event->action), event->target,
	+ event->client, event->origin);
	+ break;
	+ }
	+
	+ free(buf);
	+ crm_time_free(crm_when);
	+ return 0;
	+}
	+
	+static pcmk__message_entry_t fmt_functions[] = {
	+ { "ban", "console", pe__ban_text },
	+ { "bundle", "console", pe__bundle_text },
	+ { "clone", "console", pe__clone_text },
	+ { "cluster-counts", "console", pe__cluster_counts_text },
	+ { "cluster-dc", "console", pe__cluster_dc_text },
	+ { "cluster-options", "console", pe__cluster_options_text },
	+ { "cluster-stack", "console", pe__cluster_stack_text },
	+ { "cluster-times", "console", pe__cluster_times_text },
	+ { "failed-action", "console", pe__failed_action_text },
	+ { "group", "console", pe__group_text },
	+ { "node", "console", pe__node_text },
	+ { "node-attribute", "console", pe__node_attribute_text },
	+ { "op-history", "console", pe__op_history_text },
	+ { "primitive", "console", pe__resource_text },
	+ { "resource-history", "console", pe__resource_history_text },
	+ { "stonith-event", "console", stonith_event_console },
	+ { "ticket", "console", pe__ticket_text },
	+
	+ { NULL, NULL, NULL }
	+};
	+
	+void
	+crm_mon_register_messages(pcmk__output_t *out) {
	+ pcmk__register_messages(out, fmt_functions);
	+}
	+
	#else

	pcmk__output_t *
	crm_mon_mk_curses_output(char **argv) {
	/* curses was disabled in the build, so fall back to text. */
	return pcmk__mk_text_output(argv);
	}

	G_GNUC_PRINTF(2, 0)
	void
	curses_indented_vprintf(pcmk__output_t out, const char format, va_list args) {
	return;
	}

	G_GNUC_PRINTF(2, 3)
	void
	curses_indented_printf(pcmk__output_t out, const char format, va_list args) {
	return;
	}

	+void
	+crm_mon_register_messages(pcmk__output_t *out) {
	+ return;
	+}
	+
	#endif
	diff --git a/tools/crm_mon_output.c b/tools/crm_mon_output.c
	deleted file mode 100644
	index 5906808ff9..0000000000
	--- a/tools/crm_mon_output.c
	+++ /dev/null
	@@ -1,113 +0,0 @@
	-/*
	- * Copyright 2019 the Pacemaker project contributors
	- *
	- * The version control history for this file may have further details.
	- *
	- * This source code is licensed under the GNU General Public License version 2
	- * or later (GPLv2+) WITHOUT ANY WARRANTY.
	- */
	-
	-#include <glib.h>
	-#include <stdarg.h>
	-
	-#include <crm/stonith-ng.h>
	-#include <crm/common/iso8601.h>
	-#include <crm/common/iso8601_internal.h>
	-#include <crm/common/output.h>
	-#include <crm/common/util.h>
	-#include <crm/common/xml.h>
	-#include <crm/common/internal.h>
	-#include <crm/pengine/internal.h>
	-#include <crm/msg_xml.h>
	-#include <crm/pengine/pe_types.h>
	-
	-#include "crm_mon.h"
	-
	-static int
	-stonith_event_console(pcmk__output_t *out, va_list args) {
	- stonith_history_t event = va_arg(args, stonith_history_t );
	- int full_history = va_arg(args, int);
	- gboolean later_succeeded = va_arg(args, gboolean);
	-
	- crm_time_t *crm_when = crm_time_new(NULL);
	- char *buf = NULL;
	-
	- crm_time_set_timet(crm_when, &(event->completed));
	- buf = crm_time_as_string(crm_when, crm_time_log_date \| crm_time_log_timeofday \| crm_time_log_with_timezone);
	-
	- switch (event->state) {
	- case st_failed:
	- curses_indented_printf(out, "%s of %s failed: delegate=%s, client=%s, origin=%s, %s='%s %s'\n",
	- stonith_action_str(event->action), event->target,
	- event->delegate ? event->delegate : "",
	- event->client, event->origin,
	- full_history ? "completed" : "last-failed", buf,
	- later_succeeded ? "(a later attempt succeeded)" : "");
	- break;
	-
	- case st_done:
	- curses_indented_printf(out, "%s of %s successful: delegate=%s, client=%s, origin=%s, %s='%s'\n",
	- stonith_action_str(event->action), event->target,
	- event->delegate ? event->delegate : "",
	- event->client, event->origin,
	- full_history ? "completed" : "last-successful", buf);
	- break;
	-
	- default:
	- curses_indented_printf(out, "%s of %s pending: client=%s, origin=%s\n",
	- stonith_action_str(event->action), event->target,
	- event->client, event->origin);
	- break;
	- }
	-
	- free(buf);
	- crm_time_free(crm_when);
	- return 0;
	-}
	-
	-static int
	-ticket_console(pcmk__output_t *out, va_list args) {
	- ticket_t ticket = va_arg(args, ticket_t );
	-
	- if (ticket->last_granted > -1) {
	- char *time = pcmk_format_named_time("last-granted", ticket->last_granted);
	- out->list_item(out, ticket->id, "\t%s%s %s",
	- ticket->granted ? "granted" : "revoked",
	- ticket->standby ? " [standby]" : "",
	- time);
	- free(time);
	- } else {
	- out->list_item(out, ticket->id, "\t%s%s",
	- ticket->granted ? "granted" : "revoked",
	- ticket->standby ? " [standby]" : "");
	- }
	-
	- return 0;
	-}
	-
	-static pcmk__message_entry_t fmt_functions[] = {
	- { "ban", "console", pe__ban_text },
	- { "bundle", "console", pe__bundle_text },
	- { "clone", "console", pe__clone_text },
	- { "cluster-counts", "console", pe__cluster_counts_text },
	- { "cluster-dc", "console", pe__cluster_dc_text },
	- { "cluster-options", "console", pe__cluster_options_text },
	- { "cluster-stack", "console", pe__cluster_stack_text },
	- { "cluster-times", "console", pe__cluster_times_text },
	- { "failed-action", "console", pe__failed_action_text },
	- { "group", "console", pe__group_text },
	- { "node", "console", pe__node_text },
	- { "node-attribute", "console", pe__node_attribute_text },
	- { "op-history", "console", pe__op_history_text },
	- { "primitive", "console", pe__resource_text },
	- { "resource-history", "console", pe__resource_history_text },
	- { "stonith-event", "console", stonith_event_console },
	- { "ticket", "console", ticket_console },
	-
	- { NULL, NULL, NULL }
	-};
	-
	-void
	-crm_mon_register_messages(pcmk__output_t *out) {
	- pcmk__register_messages(out, fmt_functions);
	-}

File Metadata

Mime Type: text/x-diff
Expires: Sat, Jan 25, 11:15 AM (1 d, 10 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1322313
Default Alt Text: (89 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions