[babeltrace.git] / src / plugins / text / details / details.c

/*
 * SPDX-License-Identifier: MIT
 *
 * Copyright 2019 Philippe Proulx <pproulx@efficios.com>
 */

#define BT_COMP_LOG_SELF_COMP (details_comp->self_comp)
#define BT_LOG_OUTPUT_LEVEL (details_comp->log_level)
#define BT_LOG_TAG "PLUGIN/SINK.TEXT.DETAILS"
#include "logging/comp-logging.h"

#include <stdbool.h>

#include <babeltrace2/babeltrace.h>

#include "common/common.h"
#include "common/assert.h"
#include "details.h"
#include "write.h"
#include "plugins/common/param-validation/param-validation.h"

#define IN_PORT_NAME "in"
#define COLOR_PARAM_NAME "color"
#define WITH_METADATA_PARAM_NAME "with-metadata"
#define WITH_DATA_PARAM_NAME "with-data"
#define WITH_TIME_PARAM_NAME "with-time"
#define WITH_TRACE_NAME_PARAM_NAME "with-trace-name"
#define WITH_STREAM_CLASS_NAME_PARAM_NAME "with-stream-class-name"
#define WITH_STREAM_NAME_PARAM_NAME "with-stream-name"
#define WITH_UUID_PARAM_NAME "with-uuid"
#define COMPACT_PARAM_NAME "compact"

void details_destroy_details_trace_class_meta(
		struct details_trace_class_meta *details_tc_meta)
{
	if (!details_tc_meta) {
		goto end;
	}

	if (details_tc_meta->objects) {
		g_hash_table_destroy(details_tc_meta->objects);
		details_tc_meta->objects = NULL;
	}

	g_free(details_tc_meta);

end:
	return;
}

struct details_trace_class_meta *details_create_details_trace_class_meta(void)
{
	struct details_trace_class_meta *details_tc_meta =
		g_new0(struct details_trace_class_meta, 1);

	if (!details_tc_meta) {
		goto end;
	}

	details_tc_meta->objects = g_hash_table_new(
		g_direct_hash, g_direct_equal);
	if (!details_tc_meta->objects) {
		details_destroy_details_trace_class_meta(details_tc_meta);
		details_tc_meta = NULL;
		goto end;
	}

	details_tc_meta->tc_destruction_listener_id = UINT64_C(-1);

end:
	return details_tc_meta;
}

static
void destroy_details_comp(struct details_comp *details_comp)
{
	GHashTableIter iter;
	gpointer key, value;

	if (!details_comp) {
		goto end;
	}

	if (details_comp->meta) {
		/*
		 * Remove trace class destruction listeners, because
		 * otherwise, when they are called, `details_comp`
		 * (their user data) won't exist anymore (we're
		 * destroying it here).
		 */
		g_hash_table_iter_init(&iter, details_comp->meta);

		while (g_hash_table_iter_next(&iter, &key, &value)) {
			struct details_trace_class_meta *details_tc_meta =
				value;

			if (details_tc_meta->tc_destruction_listener_id !=
					UINT64_C(-1)) {
				if (bt_trace_class_remove_destruction_listener(
						(const void *) key,
						details_tc_meta->tc_destruction_listener_id)) {
					bt_current_thread_clear_error();
				}
			}
		}

		g_hash_table_destroy(details_comp->meta);
		details_comp->meta = NULL;
	}

	if (details_comp->traces) {
		/*
		 * Remove trace destruction listeners, because
		 * otherwise, when they are called, `details_comp` won't
		 * exist anymore (we're destroying it here).
		 */
		g_hash_table_iter_init(&iter, details_comp->traces);

		while (g_hash_table_iter_next(&iter, &key, &value)) {
			struct details_trace *details_trace = value;

			if (bt_trace_remove_destruction_listener(
					(const void *) key,
					details_trace->trace_destruction_listener_id)) {
				bt_current_thread_clear_error();
			}
		}

		g_hash_table_destroy(details_comp->traces);
		details_comp->traces = NULL;
	}

	if (details_comp->str) {
		g_string_free(details_comp->str, TRUE);
		details_comp->str = NULL;
	}

	BT_MESSAGE_ITERATOR_PUT_REF_AND_RESET(
		details_comp->msg_iter);
	g_free(details_comp);

end:
	return;
}

static
struct details_comp *create_details_comp(
		bt_self_component_sink *self_comp_sink)
{
	struct details_comp *details_comp = g_new0(struct details_comp, 1);
	bt_self_component *self_comp =
		bt_self_component_sink_as_self_component(self_comp_sink);

	if (!details_comp) {
		goto error;
	}

	details_comp->log_level = bt_component_get_logging_level(
		bt_self_component_as_component(self_comp));
	details_comp->self_comp = self_comp;
	details_comp->meta = g_hash_table_new_full(g_direct_hash,
		g_direct_equal, NULL,
		(GDestroyNotify) details_destroy_details_trace_class_meta);
	if (!details_comp->meta) {
		goto error;
	}

	details_comp->traces = g_hash_table_new_full(g_direct_hash,
		g_direct_equal, NULL, g_free);
	if (!details_comp->traces) {
		goto error;
	}

	details_comp->str = g_string_new(NULL);
	if (!details_comp->str) {
		goto error;
	}

	goto end;

error:
	destroy_details_comp(details_comp);
	details_comp = NULL;

end:
	return details_comp;
}

void details_finalize(bt_self_component_sink *comp)
{
	struct details_comp *details_comp;

	BT_ASSERT(comp);
	details_comp = bt_self_component_get_data(
		bt_self_component_sink_as_self_component(comp));
	BT_ASSERT(details_comp);
	destroy_details_comp(details_comp);
}

static
void configure_bool_opt(const bt_value *params, const char *param_name,
		bool default_value, bool *opt_value)
{
	const bt_value *value;

	*opt_value = default_value;
	value = bt_value_map_borrow_entry_value_const(params, param_name);
	if (value) {
		*opt_value = (bool) bt_value_bool_get(value);
	}
}

static const char *color_choices[] = { "never", "auto", "always", NULL };

static const struct bt_param_validation_map_value_entry_descr details_params[] = {
	{ COLOR_PARAM_NAME, BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { BT_VALUE_TYPE_STRING, .string = {
		.choices = color_choices,
	} } },
	{ WITH_METADATA_PARAM_NAME, BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
	{ WITH_DATA_PARAM_NAME, BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
	{ COMPACT_PARAM_NAME, BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
	{ WITH_TIME_PARAM_NAME, BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
	{ WITH_TRACE_NAME_PARAM_NAME, BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
	{ WITH_STREAM_CLASS_NAME_PARAM_NAME, BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
	{ WITH_STREAM_NAME_PARAM_NAME, BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
	{ WITH_UUID_PARAM_NAME, BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
	BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_END
};

static
bt_component_class_initialize_method_status configure_details_comp(
		struct details_comp *details_comp,
		const bt_value *params)
{
	bt_component_class_initialize_method_status status;
	const bt_value *value;
	const char *str;
	enum bt_param_validation_status validation_status;
	gchar *validate_error = NULL;

	validation_status = bt_param_validation_validate(params,
		details_params, &validate_error);
	if (validation_status == BT_PARAM_VALIDATION_STATUS_MEMORY_ERROR) {
		status = BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_MEMORY_ERROR;
		goto end;
	} else if (validation_status == BT_PARAM_VALIDATION_STATUS_VALIDATION_ERROR) {
		status = BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_ERROR;
		BT_COMP_LOGE_APPEND_CAUSE(details_comp->self_comp,
			"%s", validate_error);
		goto end;
	}

	/* Colorize output? */
	details_comp->cfg.with_color = bt_common_colors_supported();
	value = bt_value_map_borrow_entry_value_const(params, COLOR_PARAM_NAME);
	if (value) {
		str = bt_value_string_get(value);

		if (strcmp(str, "never") == 0) {
			details_comp->cfg.with_color = false;
		} else if (strcmp(str, "auto") == 0) {
			details_comp->cfg.with_color =
				bt_common_colors_supported();
		} else {
			BT_ASSERT(strcmp(str, "always") == 0);

			details_comp->cfg.with_color = true;
		}
	}

	/* With metadata objects? */
	configure_bool_opt(params, WITH_METADATA_PARAM_NAME, true,
		&details_comp->cfg.with_meta);

	/* With data objects? */
	configure_bool_opt(params, WITH_DATA_PARAM_NAME, true,
		&details_comp->cfg.with_data);

	/* Compact? */
	configure_bool_opt(params, COMPACT_PARAM_NAME, false,
		&details_comp->cfg.compact);

	/* With time? */
	configure_bool_opt(params, WITH_TIME_PARAM_NAME, true,
		&details_comp->cfg.with_time);

	/* With trace name? */
	configure_bool_opt(params, WITH_TRACE_NAME_PARAM_NAME, true,
		&details_comp->cfg.with_trace_name);

	/* With stream class name? */
	configure_bool_opt(params, WITH_STREAM_CLASS_NAME_PARAM_NAME, true,
		&details_comp->cfg.with_stream_class_name);

	/* With stream name? */
	configure_bool_opt(params, WITH_STREAM_NAME_PARAM_NAME, true,
		&details_comp->cfg.with_stream_name);

	/* With UUID? */
	configure_bool_opt(params, WITH_UUID_PARAM_NAME, true,
		&details_comp->cfg.with_uuid);

	status = BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_OK;
	goto end;

end:
	g_free(validate_error);

	return status;
}

static
void log_configuration(bt_self_component_sink *comp,
		struct details_comp *details_comp)
{
	BT_COMP_LOGI("Configuration for `sink.text.details` component `%s`:",
		bt_component_get_name(bt_self_component_as_component(
			bt_self_component_sink_as_self_component(comp))));
	BT_COMP_LOGI("  Colorize output: %d", details_comp->cfg.with_color);
	BT_COMP_LOGI("  Compact: %d", details_comp->cfg.compact);
	BT_COMP_LOGI("  With metadata: %d", details_comp->cfg.with_meta);
	BT_COMP_LOGI("  With time: %d", details_comp->cfg.with_time);
	BT_COMP_LOGI("  With trace name: %d", details_comp->cfg.with_trace_name);
	BT_COMP_LOGI("  With stream class name: %d",
		details_comp->cfg.with_stream_class_name);
	BT_COMP_LOGI("  With stream name: %d", details_comp->cfg.with_stream_name);
	BT_COMP_LOGI("  With UUID: %d", details_comp->cfg.with_uuid);
}

bt_component_class_initialize_method_status details_init(
		bt_self_component_sink *comp,
		bt_self_component_sink_configuration *config __attribute__((unused)),
		const bt_value *params,
		void *init_method_data __attribute__((unused)))
{
	bt_component_class_initialize_method_status status;
	bt_self_component_add_port_status add_port_status;
	struct details_comp *details_comp;
	bt_self_component *self_comp =
		bt_self_component_sink_as_self_component(comp);
	bt_logging_level log_level =
		bt_component_get_logging_level(
			bt_self_component_as_component(self_comp));

	details_comp = create_details_comp(comp);
	if (!details_comp) {
		/*
		 * Don't use BT_COMP_LOGE_APPEND_CAUSE, as `details_comp` is not
		 * initialized yet.
		 */
		BT_COMP_LOG_CUR_LVL(BT_LOG_ERROR, log_level, self_comp,
				"Failed to allocate component.");
		BT_CURRENT_THREAD_ERROR_APPEND_CAUSE_FROM_COMPONENT(
			self_comp, "Failed to allocate component.");
		status = BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_MEMORY_ERROR;
		goto error;
	}

	add_port_status = bt_self_component_sink_add_input_port(comp,
		IN_PORT_NAME, NULL, NULL);
	if (add_port_status != BT_SELF_COMPONENT_ADD_PORT_STATUS_OK) {
		BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Failed to add input port.");
		status = (int) add_port_status;
		goto error;
	}

	status = configure_details_comp(details_comp, params);
	if (status != BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_OK) {
		BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Failed to configure component.");
		goto error;
	}

	log_configuration(comp, details_comp);
	bt_self_component_set_data(
		bt_self_component_sink_as_self_component(comp), details_comp);
	goto end;

error:
	destroy_details_comp(details_comp);

end:
	return status;
}

bt_component_class_sink_graph_is_configured_method_status
details_graph_is_configured(bt_self_component_sink *comp)
{
	bt_component_class_sink_graph_is_configured_method_status status;
	bt_message_iterator_create_from_sink_component_status
		msg_iter_status;
	bt_message_iterator *iterator;
	bt_self_component_port_input *in_port;
	bt_self_component *self_comp =
		bt_self_component_sink_as_self_component(comp);
	struct details_comp *details_comp = bt_self_component_get_data(self_comp);

	BT_ASSERT(details_comp);

	in_port = bt_self_component_sink_borrow_input_port_by_name(comp,
		IN_PORT_NAME);
	if (!bt_port_is_connected(bt_port_input_as_port_const(
			bt_self_component_port_input_as_port_input(in_port)))) {
		BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Single input port is not connected: "
			"port-name=\"%s\"", IN_PORT_NAME);
		status = BT_COMPONENT_CLASS_SINK_GRAPH_IS_CONFIGURED_METHOD_STATUS_ERROR;
		goto end;
	}

	msg_iter_status = bt_message_iterator_create_from_sink_component(
		comp, in_port, &iterator);
	if (msg_iter_status != BT_MESSAGE_ITERATOR_CREATE_FROM_SINK_COMPONENT_STATUS_OK) {
		BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Failed to create message iterator: "
			"port-name=\"%s\"", IN_PORT_NAME);
		status = (int) msg_iter_status;
		goto end;
	}

	BT_MESSAGE_ITERATOR_MOVE_REF(
		details_comp->msg_iter, iterator);

	status = BT_COMPONENT_CLASS_SINK_GRAPH_IS_CONFIGURED_METHOD_STATUS_OK;

end:
	return status;
}

bt_component_class_sink_consume_method_status
details_consume(bt_self_component_sink *comp)
{
	bt_component_class_sink_consume_method_status status;
	bt_message_array_const msgs;
	uint64_t count;
	bt_message_iterator_next_status next_status;
	uint64_t i;
	bt_self_component *self_comp = bt_self_component_sink_as_self_component(comp);
	struct details_comp *details_comp = bt_self_component_get_data(self_comp);

	BT_ASSERT_DBG(details_comp);
	BT_ASSERT_DBG(details_comp->msg_iter);

	/* Consume messages */
	next_status = bt_message_iterator_next(
		details_comp->msg_iter, &msgs, &count);
	if (next_status != BT_MESSAGE_ITERATOR_NEXT_STATUS_OK) {
		status = (int) next_status;
		goto end;
	}

	for (i = 0; i < count; i++) {
		int print_ret = details_write_message(details_comp,
			msgs[i]);

		if (print_ret) {
			for (; i < count; i++) {
				/* Put all remaining messages */
				bt_message_put_ref(msgs[i]);
			}

			BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Failed to write message.");
			status = BT_COMPONENT_CLASS_SINK_CONSUME_METHOD_STATUS_ERROR;
			goto end;
		}

		/* Print output buffer to standard output and flush */
		if (details_comp->str->len > 0) {
			printf("%s", details_comp->str->str);
			fflush(stdout);
			details_comp->printed_something = true;
		}

		/* Put this message */
		bt_message_put_ref(msgs[i]);
	}

	status = BT_COMPONENT_CLASS_SINK_CONSUME_METHOD_STATUS_OK;

end:
	return status;
}
Commit	Line	Data
55478183	1	/*
0235b0db	2	* SPDX-License-Identifier: MIT
55478183	3	*
0235b0db	4	* Copyright 2019 Philippe Proulx <pproulx@efficios.com>
55478183 PP	5	*/
55478183 PP	6
d400b9e6	7	#define BT_COMP_LOG_SELF_COMP (details_comp->self_comp)
6c868a3a	8	#define BT_LOG_OUTPUT_LEVEL (details_comp->log_level)
350ad6c1	9	#define BT_LOG_TAG "PLUGIN/SINK.TEXT.DETAILS"
d9c39b0a	10	#include "logging/comp-logging.h"
55478183	11
c4f23e30 FD	12	#include <stdbool.h>
c4f23e30 FD	13
55478183 PP	14	#include <babeltrace2/babeltrace.h>
	15
	16	#include "common/common.h"
	17	#include "common/assert.h"
	18	#include "details.h"
	19	#include "write.h"
48a0e52c	20	#include "plugins/common/param-validation/param-validation.h"
55478183	21
48a0e52c SM	22	#define IN_PORT_NAME "in"
	23	#define COLOR_PARAM_NAME "color"
	24	#define WITH_METADATA_PARAM_NAME "with-metadata"
	25	#define WITH_DATA_PARAM_NAME "with-data"
	26	#define WITH_TIME_PARAM_NAME "with-time"
	27	#define WITH_TRACE_NAME_PARAM_NAME "with-trace-name"
	28	#define WITH_STREAM_CLASS_NAME_PARAM_NAME "with-stream-class-name"
	29	#define WITH_STREAM_NAME_PARAM_NAME "with-stream-name"
	30	#define WITH_UUID_PARAM_NAME "with-uuid"
	31	#define COMPACT_PARAM_NAME "compact"
55478183	32
55478183 PP	33	void details_destroy_details_trace_class_meta(
	34	struct details_trace_class_meta *details_tc_meta)
	35	{
	36	if (!details_tc_meta) {
	37	goto end;
	38	}
	39
	40	if (details_tc_meta->objects) {
	41	g_hash_table_destroy(details_tc_meta->objects);
	42	details_tc_meta->objects = NULL;
	43	}
	44
	45	g_free(details_tc_meta);
	46
	47	end:
	48	return;
	49	}
	50
55478183 PP	51	struct details_trace_class_meta *details_create_details_trace_class_meta(void)
	52	{
	53	struct details_trace_class_meta *details_tc_meta =
	54	g_new0(struct details_trace_class_meta, 1);
	55
	56	if (!details_tc_meta) {
	57	goto end;
	58	}
	59
	60	details_tc_meta->objects = g_hash_table_new(
	61	g_direct_hash, g_direct_equal);
	62	if (!details_tc_meta->objects) {
	63	details_destroy_details_trace_class_meta(details_tc_meta);
	64	details_tc_meta = NULL;
	65	goto end;
	66	}
	67
	68	details_tc_meta->tc_destruction_listener_id = UINT64_C(-1);
	69
	70	end:
	71	return details_tc_meta;
	72	}
	73
	74	static
	75	void destroy_details_comp(struct details_comp *details_comp)
	76	{
	77	GHashTableIter iter;
	78	gpointer key, value;
	79
	80	if (!details_comp) {
	81	goto end;
	82	}
	83
	84	if (details_comp->meta) {
	85	/*
	86	* Remove trace class destruction listeners, because
	87	* otherwise, when they are called, `details_comp`
	88	* (their user data) won't exist anymore (we're
	89	* destroying it here).
	90	*/
	91	g_hash_table_iter_init(&iter, details_comp->meta);
	92
	93	while (g_hash_table_iter_next(&iter, &key, &value)) {
	94	struct details_trace_class_meta *details_tc_meta =
	95	value;
	96
	97	if (details_tc_meta->tc_destruction_listener_id !=
	98	UINT64_C(-1)) {
b80991f6 PP	99	if (bt_trace_class_remove_destruction_listener(
	100	(const void *) key,
	101	details_tc_meta->tc_destruction_listener_id)) {
	102	bt_current_thread_clear_error();
	103	}
55478183 PP	104	}
	105	}
	106
	107	g_hash_table_destroy(details_comp->meta);
	108	details_comp->meta = NULL;
	109	}
	110
	111	if (details_comp->traces) {
	112	/*
	113	* Remove trace destruction listeners, because
	114	* otherwise, when they are called, `details_comp` won't
	115	* exist anymore (we're destroying it here).
	116	*/
	117	g_hash_table_iter_init(&iter, details_comp->traces);
	118
	119	while (g_hash_table_iter_next(&iter, &key, &value)) {
	120	struct details_trace *details_trace = value;
	121
b80991f6 PP	122	if (bt_trace_remove_destruction_listener(
	123	(const void *) key,
	124	details_trace->trace_destruction_listener_id)) {
	125	bt_current_thread_clear_error();
	126	}
55478183 PP	127	}
	128
	129	g_hash_table_destroy(details_comp->traces);
	130	details_comp->traces = NULL;
	131	}
	132
	133	if (details_comp->str) {
	134	g_string_free(details_comp->str, TRUE);
	135	details_comp->str = NULL;
	136	}
	137
9a2c8b8e	138	BT_MESSAGE_ITERATOR_PUT_REF_AND_RESET(
55478183 PP	139	details_comp->msg_iter);
	140	g_free(details_comp);
	141
	142	end:
	143	return;
	144	}
	145
	146	static
6c868a3a PP	147	struct details_comp *create_details_comp(
6c868a3a PP	148	bt_self_component_sink *self_comp_sink)
55478183 PP	149	{
55478183 PP	150	struct details_comp *details_comp = g_new0(struct details_comp, 1);
6c868a3a PP	151	bt_self_component *self_comp =
6c868a3a PP	152	bt_self_component_sink_as_self_component(self_comp_sink);
55478183 PP	153
	154	if (!details_comp) {
	155	goto error;
	156	}
	157
6c868a3a PP	158	details_comp->log_level = bt_component_get_logging_level(
6c868a3a PP	159	bt_self_component_as_component(self_comp));
d400b9e6	160	details_comp->self_comp = self_comp;
55478183 PP	161	details_comp->meta = g_hash_table_new_full(g_direct_hash,
	162	g_direct_equal, NULL,
	163	(GDestroyNotify) details_destroy_details_trace_class_meta);
	164	if (!details_comp->meta) {
	165	goto error;
	166	}
	167
	168	details_comp->traces = g_hash_table_new_full(g_direct_hash,
	169	g_direct_equal, NULL, g_free);
	170	if (!details_comp->traces) {
	171	goto error;
	172	}
	173
	174	details_comp->str = g_string_new(NULL);
	175	if (!details_comp->str) {
	176	goto error;
	177	}
	178
	179	goto end;
	180
	181	error:
	182	destroy_details_comp(details_comp);
	183	details_comp = NULL;
	184
	185	end:
	186	return details_comp;
	187	}
	188
55478183 PP	189	void details_finalize(bt_self_component_sink *comp)
	190	{
	191	struct details_comp *details_comp;
	192
	193	BT_ASSERT(comp);
	194	details_comp = bt_self_component_get_data(
	195	bt_self_component_sink_as_self_component(comp));
	196	BT_ASSERT(details_comp);
	197	destroy_details_comp(details_comp);
	198	}
	199
	200	static
f9ccd9da	201	void configure_bool_opt(const bt_value params, const char param_name,
55478183 PP	202	bool default_value, bool *opt_value)
55478183 PP	203	{
55478183 PP	204	const bt_value *value;
	205
	206	*opt_value = default_value;
	207	value = bt_value_map_borrow_entry_value_const(params, param_name);
	208	if (value) {
55478183 PP	209	*opt_value = (bool) bt_value_bool_get(value);
55478183 PP	210	}
55478183 PP	211	}
55478183 PP	212
48a0e52c SM	213	static const char *color_choices[] = { "never", "auto", "always", NULL };
	214
	215	static const struct bt_param_validation_map_value_entry_descr details_params[] = {
	216	{ COLOR_PARAM_NAME, BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { BT_VALUE_TYPE_STRING, .string = {
	217	.choices = color_choices,
	218	} } },
	219	{ WITH_METADATA_PARAM_NAME, BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
	220	{ WITH_DATA_PARAM_NAME, BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
	221	{ COMPACT_PARAM_NAME, BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
	222	{ WITH_TIME_PARAM_NAME, BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
	223	{ WITH_TRACE_NAME_PARAM_NAME, BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
	224	{ WITH_STREAM_CLASS_NAME_PARAM_NAME, BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
	225	{ WITH_STREAM_NAME_PARAM_NAME, BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
	226	{ WITH_UUID_PARAM_NAME, BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
	227	BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_END
	228	};
	229
55478183	230	static
48a0e52c SM	231	bt_component_class_initialize_method_status configure_details_comp(
48a0e52c SM	232	struct details_comp *details_comp,
55478183 PP	233	const bt_value *params)
55478183 PP	234	{
48a0e52c	235	bt_component_class_initialize_method_status status;
55478183 PP	236	const bt_value *value;
55478183 PP	237	const char *str;
48a0e52c SM	238	enum bt_param_validation_status validation_status;
	239	gchar *validate_error = NULL;
	240
	241	validation_status = bt_param_validation_validate(params,
	242	details_params, &validate_error);
	243	if (validation_status == BT_PARAM_VALIDATION_STATUS_MEMORY_ERROR) {
	244	status = BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_MEMORY_ERROR;
	245	goto end;
	246	} else if (validation_status == BT_PARAM_VALIDATION_STATUS_VALIDATION_ERROR) {
	247	status = BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_ERROR;
	248	BT_COMP_LOGE_APPEND_CAUSE(details_comp->self_comp,
	249	"%s", validate_error);
	250	goto end;
	251	}
55478183 PP	252
	253	/* Colorize output? */
	254	details_comp->cfg.with_color = bt_common_colors_supported();
48a0e52c	255	value = bt_value_map_borrow_entry_value_const(params, COLOR_PARAM_NAME);
55478183	256	if (value) {
55478183 PP	257	str = bt_value_string_get(value);
	258
	259	if (strcmp(str, "never") == 0) {
	260	details_comp->cfg.with_color = false;
	261	} else if (strcmp(str, "auto") == 0) {
	262	details_comp->cfg.with_color =
	263	bt_common_colors_supported();
55478183	264	} else {
48a0e52c SM	265	BT_ASSERT(strcmp(str, "always") == 0);
	266
	267	details_comp->cfg.with_color = true;
55478183 PP	268	}
	269	}
	270
	271	/* With metadata objects? */
f9ccd9da SM	272	configure_bool_opt(params, WITH_METADATA_PARAM_NAME, true,
f9ccd9da SM	273	&details_comp->cfg.with_meta);
55478183	274
cc413248	275	/* With data objects? */
f9ccd9da SM	276	configure_bool_opt(params, WITH_DATA_PARAM_NAME, true,
f9ccd9da SM	277	&details_comp->cfg.with_data);
cc413248	278
55478183	279	/* Compact? */
f9ccd9da SM	280	configure_bool_opt(params, COMPACT_PARAM_NAME, false,
f9ccd9da SM	281	&details_comp->cfg.compact);
55478183 PP	282
55478183 PP	283	/* With time? */
f9ccd9da SM	284	configure_bool_opt(params, WITH_TIME_PARAM_NAME, true,
f9ccd9da SM	285	&details_comp->cfg.with_time);
55478183	286
55478183	287	/* With trace name? */
f9ccd9da SM	288	configure_bool_opt(params, WITH_TRACE_NAME_PARAM_NAME, true,
f9ccd9da SM	289	&details_comp->cfg.with_trace_name);
55478183 PP	290
55478183 PP	291	/* With stream class name? */
f9ccd9da SM	292	configure_bool_opt(params, WITH_STREAM_CLASS_NAME_PARAM_NAME, true,
f9ccd9da SM	293	&details_comp->cfg.with_stream_class_name);
55478183 PP	294
55478183 PP	295	/* With stream name? */
f9ccd9da SM	296	configure_bool_opt(params, WITH_STREAM_NAME_PARAM_NAME, true,
f9ccd9da SM	297	&details_comp->cfg.with_stream_name);
55478183 PP	298
55478183 PP	299	/* With UUID? */
f9ccd9da SM	300	configure_bool_opt(params, WITH_UUID_PARAM_NAME, true,
f9ccd9da SM	301	&details_comp->cfg.with_uuid);
55478183	302
48a0e52c	303	status = BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_OK;
55478183 PP	304	goto end;
55478183 PP	305
55478183	306	end:
48a0e52c SM	307	g_free(validate_error);
	308
	309	return status;
55478183 PP	310	}
	311
	312	static
	313	void log_configuration(bt_self_component_sink *comp,
	314	struct details_comp *details_comp)
	315	{
d400b9e6	316	BT_COMP_LOGI("Configuration for `sink.text.details` component `%s`:",
55478183 PP	317	bt_component_get_name(bt_self_component_as_component(
55478183 PP	318	bt_self_component_sink_as_self_component(comp))));
d400b9e6 PP	319	BT_COMP_LOGI(" Colorize output: %d", details_comp->cfg.with_color);
	320	BT_COMP_LOGI(" Compact: %d", details_comp->cfg.compact);
	321	BT_COMP_LOGI(" With metadata: %d", details_comp->cfg.with_meta);
	322	BT_COMP_LOGI(" With time: %d", details_comp->cfg.with_time);
d400b9e6 PP	323	BT_COMP_LOGI(" With trace name: %d", details_comp->cfg.with_trace_name);
d400b9e6 PP	324	BT_COMP_LOGI(" With stream class name: %d",
55478183	325	details_comp->cfg.with_stream_class_name);
d400b9e6 PP	326	BT_COMP_LOGI(" With stream name: %d", details_comp->cfg.with_stream_name);
d400b9e6 PP	327	BT_COMP_LOGI(" With UUID: %d", details_comp->cfg.with_uuid);
55478183 PP	328	}
55478183 PP	329
21a9f056	330	bt_component_class_initialize_method_status details_init(
59225a3e	331	bt_self_component_sink *comp,
ecd7492f	332	bt_self_component_sink_configuration *config __attribute__((unused)),
55478183	333	const bt_value *params,
ecd7492f	334	void *init_method_data __attribute__((unused)))
55478183	335	{
25a74fea	336	bt_component_class_initialize_method_status status;
d24d5663	337	bt_self_component_add_port_status add_port_status;
25a74fea SM	338	struct details_comp *details_comp;
	339	bt_self_component *self_comp =
	340	bt_self_component_sink_as_self_component(comp);
	341	bt_logging_level log_level =
	342	bt_component_get_logging_level(
	343	bt_self_component_as_component(self_comp));
	344
	345	details_comp = create_details_comp(comp);
	346	if (!details_comp) {
	347	/*
	348	* Don't use BT_COMP_LOGE_APPEND_CAUSE, as `details_comp` is not
	349	* initialized yet.
	350	*/
	351	BT_COMP_LOG_CUR_LVL(BT_LOG_ERROR, log_level, self_comp,
	352	"Failed to allocate component.");
	353	BT_CURRENT_THREAD_ERROR_APPEND_CAUSE_FROM_COMPONENT(
	354	self_comp, "Failed to allocate component.");
	355	status = BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_MEMORY_ERROR;
	356	goto error;
	357	}
55478183	358
d24d5663	359	add_port_status = bt_self_component_sink_add_input_port(comp,
48a0e52c	360	IN_PORT_NAME, NULL, NULL);
c7f21c12	361	if (add_port_status != BT_SELF_COMPONENT_ADD_PORT_STATUS_OK) {
25a74fea	362	BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Failed to add input port.");
c7f21c12 SM	363	status = (int) add_port_status;
c7f21c12 SM	364	goto error;
55478183 PP	365	}
55478183 PP	366
25a74fea SM	367	status = configure_details_comp(details_comp, params);
	368	if (status != BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_OK) {
	369	BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Failed to configure component.");
55478183 PP	370	goto error;
	371	}
	372
	373	log_configuration(comp, details_comp);
	374	bt_self_component_set_data(
	375	bt_self_component_sink_as_self_component(comp), details_comp);
	376	goto end;
	377
	378	error:
55478183 PP	379	destroy_details_comp(details_comp);
	380
	381	end:
	382	return status;
	383	}
	384
d24d5663 PP	385	bt_component_class_sink_graph_is_configured_method_status
d24d5663 PP	386	details_graph_is_configured(bt_self_component_sink *comp)
55478183	387	{
e803df70	388	bt_component_class_sink_graph_is_configured_method_status status;
9a2c8b8e	389	bt_message_iterator_create_from_sink_component_status
e803df70	390	msg_iter_status;
9a2c8b8e	391	bt_message_iterator *iterator;
55478183	392	bt_self_component_port_input *in_port;
25a74fea SM	393	bt_self_component *self_comp =
	394	bt_self_component_sink_as_self_component(comp);
	395	struct details_comp *details_comp = bt_self_component_get_data(self_comp);
55478183	396
55478183	397	BT_ASSERT(details_comp);
25a74fea	398
55478183	399	in_port = bt_self_component_sink_borrow_input_port_by_name(comp,
48a0e52c	400	IN_PORT_NAME);
55478183 PP	401	if (!bt_port_is_connected(bt_port_input_as_port_const(
55478183 PP	402	bt_self_component_port_input_as_port_input(in_port)))) {
25a74fea	403	BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Single input port is not connected: "
48a0e52c	404	"port-name=\"%s\"", IN_PORT_NAME);
d24d5663	405	status = BT_COMPONENT_CLASS_SINK_GRAPH_IS_CONFIGURED_METHOD_STATUS_ERROR;
55478183 PP	406	goto end;
	407	}
	408
9a2c8b8e	409	msg_iter_status = bt_message_iterator_create_from_sink_component(
25a74fea	410	comp, in_port, &iterator);
9a2c8b8e	411	if (msg_iter_status != BT_MESSAGE_ITERATOR_CREATE_FROM_SINK_COMPONENT_STATUS_OK) {
25a74fea SM	412	BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Failed to create message iterator: "
25a74fea SM	413	"port-name=\"%s\"", IN_PORT_NAME);
e803df70	414	status = (int) msg_iter_status;
55478183 PP	415	goto end;
	416	}
	417
9a2c8b8e	418	BT_MESSAGE_ITERATOR_MOVE_REF(
55478183 PP	419	details_comp->msg_iter, iterator);
55478183 PP	420
e803df70 SM	421	status = BT_COMPONENT_CLASS_SINK_GRAPH_IS_CONFIGURED_METHOD_STATUS_OK;
e803df70 SM	422
55478183 PP	423	end:
	424	return status;
	425	}
	426
d24d5663 PP	427	bt_component_class_sink_consume_method_status
d24d5663 PP	428	details_consume(bt_self_component_sink *comp)
55478183	429	{
818919b9	430	bt_component_class_sink_consume_method_status status;
55478183 PP	431	bt_message_array_const msgs;
55478183 PP	432	uint64_t count;
d24d5663	433	bt_message_iterator_next_status next_status;
55478183	434	uint64_t i;
25a74fea SM	435	bt_self_component *self_comp = bt_self_component_sink_as_self_component(comp);
25a74fea SM	436	struct details_comp *details_comp = bt_self_component_get_data(self_comp);
55478183	437
98b15851 PP	438	BT_ASSERT_DBG(details_comp);
98b15851 PP	439	BT_ASSERT_DBG(details_comp->msg_iter);
55478183 PP	440
55478183 PP	441	/* Consume messages */
9a2c8b8e	442	next_status = bt_message_iterator_next(
55478183	443	details_comp->msg_iter, &msgs, &count);
818919b9 SM	444	if (next_status != BT_MESSAGE_ITERATOR_NEXT_STATUS_OK) {
	445	status = (int) next_status;
	446	goto end;
	447	}
55478183	448
818919b9 SM	449	for (i = 0; i < count; i++) {
	450	int print_ret = details_write_message(details_comp,
	451	msgs[i]);
55478183	452
818919b9 SM	453	if (print_ret) {
	454	for (; i < count; i++) {
	455	/* Put all remaining messages */
	456	bt_message_put_ref(msgs[i]);
55478183 PP	457	}
55478183 PP	458
25a74fea	459	BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Failed to write message.");
818919b9 SM	460	status = BT_COMPONENT_CLASS_SINK_CONSUME_METHOD_STATUS_ERROR;
818919b9 SM	461	goto end;
55478183 PP	462	}
55478183 PP	463
818919b9 SM	464	/* Print output buffer to standard output and flush */
	465	if (details_comp->str->len > 0) {
	466	printf("%s", details_comp->str->str);
	467	fflush(stdout);
	468	details_comp->printed_something = true;
	469	}
	470
	471	/* Put this message */
	472	bt_message_put_ref(msgs[i]);
55478183 PP	473	}
55478183 PP	474
818919b9 SM	475	status = BT_COMPONENT_CLASS_SINK_CONSUME_METHOD_STATUS_OK;
818919b9 SM	476
55478183	477	end:
818919b9	478	return status;
55478183	479	}