[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(struct details_comp *details_comp,
		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(details_comp, params, WITH_METADATA_PARAM_NAME,
		true, &details_comp->cfg.with_meta);

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

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

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

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

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

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

	/* With UUID? */
	configure_bool_opt(details_comp, 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,
		const bt_value *params,
		__attribute__((unused)) void *init_method_data)
{
	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
48a0e52c	201	void configure_bool_opt(struct details_comp *details_comp,
55478183 PP	202	const bt_value params, const char param_name,
	203	bool default_value, bool *opt_value)
	204	{
55478183 PP	205	const bt_value *value;
	206
	207	*opt_value = default_value;
	208	value = bt_value_map_borrow_entry_value_const(params, param_name);
	209	if (value) {
55478183 PP	210	*opt_value = (bool) bt_value_bool_get(value);
55478183 PP	211	}
55478183 PP	212	}
55478183 PP	213
48a0e52c SM	214	static const char *color_choices[] = { "never", "auto", "always", NULL };
	215
	216	static const struct bt_param_validation_map_value_entry_descr details_params[] = {
	217	{ COLOR_PARAM_NAME, BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { BT_VALUE_TYPE_STRING, .string = {
	218	.choices = color_choices,
	219	} } },
	220	{ WITH_METADATA_PARAM_NAME, BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
	221	{ WITH_DATA_PARAM_NAME, BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
	222	{ COMPACT_PARAM_NAME, BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
	223	{ WITH_TIME_PARAM_NAME, BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
	224	{ WITH_TRACE_NAME_PARAM_NAME, BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
	225	{ WITH_STREAM_CLASS_NAME_PARAM_NAME, BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
	226	{ WITH_STREAM_NAME_PARAM_NAME, BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
	227	{ WITH_UUID_PARAM_NAME, BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
	228	BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_END
	229	};
	230
55478183	231	static
48a0e52c SM	232	bt_component_class_initialize_method_status configure_details_comp(
48a0e52c SM	233	struct details_comp *details_comp,
55478183 PP	234	const bt_value *params)
55478183 PP	235	{
48a0e52c	236	bt_component_class_initialize_method_status status;
55478183 PP	237	const bt_value *value;
55478183 PP	238	const char *str;
48a0e52c SM	239	enum bt_param_validation_status validation_status;
	240	gchar *validate_error = NULL;
	241
	242	validation_status = bt_param_validation_validate(params,
	243	details_params, &validate_error);
	244	if (validation_status == BT_PARAM_VALIDATION_STATUS_MEMORY_ERROR) {
	245	status = BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_MEMORY_ERROR;
	246	goto end;
	247	} else if (validation_status == BT_PARAM_VALIDATION_STATUS_VALIDATION_ERROR) {
	248	status = BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_ERROR;
	249	BT_COMP_LOGE_APPEND_CAUSE(details_comp->self_comp,
	250	"%s", validate_error);
	251	goto end;
	252	}
55478183 PP	253
	254	/* Colorize output? */
	255	details_comp->cfg.with_color = bt_common_colors_supported();
48a0e52c	256	value = bt_value_map_borrow_entry_value_const(params, COLOR_PARAM_NAME);
55478183	257	if (value) {
55478183 PP	258	str = bt_value_string_get(value);
	259
	260	if (strcmp(str, "never") == 0) {
	261	details_comp->cfg.with_color = false;
	262	} else if (strcmp(str, "auto") == 0) {
	263	details_comp->cfg.with_color =
	264	bt_common_colors_supported();
55478183	265	} else {
48a0e52c SM	266	BT_ASSERT(strcmp(str, "always") == 0);
	267
	268	details_comp->cfg.with_color = true;
55478183 PP	269	}
	270	}
	271
	272	/* With metadata objects? */
48a0e52c	273	configure_bool_opt(details_comp, params, WITH_METADATA_PARAM_NAME,
55478183	274	true, &details_comp->cfg.with_meta);
55478183	275
cc413248	276	/* With data objects? */
48a0e52c	277	configure_bool_opt(details_comp, params, WITH_DATA_PARAM_NAME,
cc413248	278	true, &details_comp->cfg.with_data);
cc413248	279
55478183	280	/* Compact? */
48a0e52c	281	configure_bool_opt(details_comp, params, COMPACT_PARAM_NAME,
55478183	282	false, &details_comp->cfg.compact);
55478183 PP	283
55478183 PP	284	/* With time? */
48a0e52c	285	configure_bool_opt(details_comp, params, WITH_TIME_PARAM_NAME,
55478183	286	true, &details_comp->cfg.with_time);
55478183	287
55478183	288	/* With trace name? */
48a0e52c SM	289	configure_bool_opt(details_comp, params,
48a0e52c SM	290	WITH_TRACE_NAME_PARAM_NAME,
55478183	291	true, &details_comp->cfg.with_trace_name);
55478183 PP	292
55478183 PP	293	/* With stream class name? */
48a0e52c SM	294	configure_bool_opt(details_comp, params,
48a0e52c SM	295	WITH_STREAM_CLASS_NAME_PARAM_NAME,
55478183	296	true, &details_comp->cfg.with_stream_class_name);
55478183 PP	297
55478183 PP	298	/* With stream name? */
48a0e52c SM	299	configure_bool_opt(details_comp, params,
48a0e52c SM	300	WITH_STREAM_NAME_PARAM_NAME,
55478183	301	true, &details_comp->cfg.with_stream_name);
55478183 PP	302
55478183 PP	303	/* With UUID? */
48a0e52c SM	304	configure_bool_opt(details_comp, params,
48a0e52c SM	305	WITH_UUID_PARAM_NAME, true, &details_comp->cfg.with_uuid);
55478183	306
48a0e52c	307	status = BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_OK;
55478183 PP	308	goto end;
55478183 PP	309
55478183	310	end:
48a0e52c SM	311	g_free(validate_error);
	312
	313	return status;
55478183 PP	314	}
	315
	316	static
	317	void log_configuration(bt_self_component_sink *comp,
	318	struct details_comp *details_comp)
	319	{
d400b9e6	320	BT_COMP_LOGI("Configuration for `sink.text.details` component `%s`:",
55478183 PP	321	bt_component_get_name(bt_self_component_as_component(
55478183 PP	322	bt_self_component_sink_as_self_component(comp))));
d400b9e6 PP	323	BT_COMP_LOGI(" Colorize output: %d", details_comp->cfg.with_color);
	324	BT_COMP_LOGI(" Compact: %d", details_comp->cfg.compact);
	325	BT_COMP_LOGI(" With metadata: %d", details_comp->cfg.with_meta);
	326	BT_COMP_LOGI(" With time: %d", details_comp->cfg.with_time);
d400b9e6 PP	327	BT_COMP_LOGI(" With trace name: %d", details_comp->cfg.with_trace_name);
d400b9e6 PP	328	BT_COMP_LOGI(" With stream class name: %d",
55478183	329	details_comp->cfg.with_stream_class_name);
d400b9e6 PP	330	BT_COMP_LOGI(" With stream name: %d", details_comp->cfg.with_stream_name);
d400b9e6 PP	331	BT_COMP_LOGI(" With UUID: %d", details_comp->cfg.with_uuid);
55478183 PP	332	}
55478183 PP	333
21a9f056	334	bt_component_class_initialize_method_status details_init(
59225a3e SM	335	bt_self_component_sink *comp,
59225a3e SM	336	bt_self_component_sink_configuration *config,
55478183 PP	337	const bt_value *params,
	338	__attribute__((unused)) void *init_method_data)
	339	{
25a74fea	340	bt_component_class_initialize_method_status status;
d24d5663	341	bt_self_component_add_port_status add_port_status;
25a74fea SM	342	struct details_comp *details_comp;
	343	bt_self_component *self_comp =
	344	bt_self_component_sink_as_self_component(comp);
	345	bt_logging_level log_level =
	346	bt_component_get_logging_level(
	347	bt_self_component_as_component(self_comp));
	348
	349	details_comp = create_details_comp(comp);
	350	if (!details_comp) {
	351	/*
	352	* Don't use BT_COMP_LOGE_APPEND_CAUSE, as `details_comp` is not
	353	* initialized yet.
	354	*/
	355	BT_COMP_LOG_CUR_LVL(BT_LOG_ERROR, log_level, self_comp,
	356	"Failed to allocate component.");
	357	BT_CURRENT_THREAD_ERROR_APPEND_CAUSE_FROM_COMPONENT(
	358	self_comp, "Failed to allocate component.");
	359	status = BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_MEMORY_ERROR;
	360	goto error;
	361	}
55478183	362
d24d5663	363	add_port_status = bt_self_component_sink_add_input_port(comp,
48a0e52c	364	IN_PORT_NAME, NULL, NULL);
c7f21c12	365	if (add_port_status != BT_SELF_COMPONENT_ADD_PORT_STATUS_OK) {
25a74fea	366	BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Failed to add input port.");
c7f21c12 SM	367	status = (int) add_port_status;
c7f21c12 SM	368	goto error;
55478183 PP	369	}
55478183 PP	370
25a74fea SM	371	status = configure_details_comp(details_comp, params);
	372	if (status != BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_OK) {
	373	BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Failed to configure component.");
55478183 PP	374	goto error;
	375	}
	376
	377	log_configuration(comp, details_comp);
	378	bt_self_component_set_data(
	379	bt_self_component_sink_as_self_component(comp), details_comp);
	380	goto end;
	381
	382	error:
55478183 PP	383	destroy_details_comp(details_comp);
	384
	385	end:
	386	return status;
	387	}
	388
d24d5663 PP	389	bt_component_class_sink_graph_is_configured_method_status
d24d5663 PP	390	details_graph_is_configured(bt_self_component_sink *comp)
55478183	391	{
e803df70	392	bt_component_class_sink_graph_is_configured_method_status status;
9a2c8b8e	393	bt_message_iterator_create_from_sink_component_status
e803df70	394	msg_iter_status;
9a2c8b8e	395	bt_message_iterator *iterator;
55478183	396	bt_self_component_port_input *in_port;
25a74fea SM	397	bt_self_component *self_comp =
	398	bt_self_component_sink_as_self_component(comp);
	399	struct details_comp *details_comp = bt_self_component_get_data(self_comp);
55478183	400
55478183	401	BT_ASSERT(details_comp);
25a74fea	402
55478183	403	in_port = bt_self_component_sink_borrow_input_port_by_name(comp,
48a0e52c	404	IN_PORT_NAME);
55478183 PP	405	if (!bt_port_is_connected(bt_port_input_as_port_const(
55478183 PP	406	bt_self_component_port_input_as_port_input(in_port)))) {
25a74fea	407	BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Single input port is not connected: "
48a0e52c	408	"port-name=\"%s\"", IN_PORT_NAME);
d24d5663	409	status = BT_COMPONENT_CLASS_SINK_GRAPH_IS_CONFIGURED_METHOD_STATUS_ERROR;
55478183 PP	410	goto end;
	411	}
	412
9a2c8b8e	413	msg_iter_status = bt_message_iterator_create_from_sink_component(
25a74fea	414	comp, in_port, &iterator);
9a2c8b8e	415	if (msg_iter_status != BT_MESSAGE_ITERATOR_CREATE_FROM_SINK_COMPONENT_STATUS_OK) {
25a74fea SM	416	BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Failed to create message iterator: "
25a74fea SM	417	"port-name=\"%s\"", IN_PORT_NAME);
e803df70	418	status = (int) msg_iter_status;
55478183 PP	419	goto end;
	420	}
	421
9a2c8b8e	422	BT_MESSAGE_ITERATOR_MOVE_REF(
55478183 PP	423	details_comp->msg_iter, iterator);
55478183 PP	424
e803df70 SM	425	status = BT_COMPONENT_CLASS_SINK_GRAPH_IS_CONFIGURED_METHOD_STATUS_OK;
e803df70 SM	426
55478183 PP	427	end:
	428	return status;
	429	}
	430
d24d5663 PP	431	bt_component_class_sink_consume_method_status
d24d5663 PP	432	details_consume(bt_self_component_sink *comp)
55478183	433	{
818919b9	434	bt_component_class_sink_consume_method_status status;
55478183 PP	435	bt_message_array_const msgs;
55478183 PP	436	uint64_t count;
d24d5663	437	bt_message_iterator_next_status next_status;
55478183	438	uint64_t i;
25a74fea SM	439	bt_self_component *self_comp = bt_self_component_sink_as_self_component(comp);
25a74fea SM	440	struct details_comp *details_comp = bt_self_component_get_data(self_comp);
55478183	441
98b15851 PP	442	BT_ASSERT_DBG(details_comp);
98b15851 PP	443	BT_ASSERT_DBG(details_comp->msg_iter);
55478183 PP	444
55478183 PP	445	/* Consume messages */
9a2c8b8e	446	next_status = bt_message_iterator_next(
55478183	447	details_comp->msg_iter, &msgs, &count);
818919b9 SM	448	if (next_status != BT_MESSAGE_ITERATOR_NEXT_STATUS_OK) {
	449	status = (int) next_status;
	450	goto end;
	451	}
55478183	452
818919b9 SM	453	for (i = 0; i < count; i++) {
	454	int print_ret = details_write_message(details_comp,
	455	msgs[i]);
55478183	456
818919b9 SM	457	if (print_ret) {
	458	for (; i < count; i++) {
	459	/* Put all remaining messages */
	460	bt_message_put_ref(msgs[i]);
55478183 PP	461	}
55478183 PP	462
25a74fea	463	BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Failed to write message.");
818919b9 SM	464	status = BT_COMPONENT_CLASS_SINK_CONSUME_METHOD_STATUS_ERROR;
818919b9 SM	465	goto end;
55478183 PP	466	}
55478183 PP	467
818919b9 SM	468	/* Print output buffer to standard output and flush */
	469	if (details_comp->str->len > 0) {
	470	printf("%s", details_comp->str->str);
	471	fflush(stdout);
	472	details_comp->printed_something = true;
	473	}
	474
	475	/* Put this message */
	476	bt_message_put_ref(msgs[i]);
55478183 PP	477	}
55478183 PP	478
818919b9 SM	479	status = BT_COMPONENT_CLASS_SINK_CONSUME_METHOD_STATUS_OK;
818919b9 SM	480
55478183	481	end:
818919b9	482	return status;
55478183	483	}