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

/*
 * Copyright 2019 Philippe Proulx <pproulx@efficios.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

#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 <babeltrace2/babeltrace.h>

#include "common/common.h"
#include "common/assert.h"
#include "details.h"
#include "write.h"

#define LOG_WRONG_PARAM_TYPE(_name, _value, _exp_type)			\
	do {								\
		BT_COMP_LOGE("Wrong `%s` parameter type: type=%s, "	\
			"expected-type=%s",				\
			(_name), bt_common_value_type_string(		\
				bt_value_get_type(_value)),		\
			bt_common_value_type_string(_exp_type));	\
	} while (0)

static
const char * const in_port_name = "in";

static
const char * const color_param_name = "color";

static
const char * const with_metadata_param_name = "with-metadata";

static
const char * const with_data_param_name = "with-data";

static
const char * const with_time_param_name = "with-time";

static
const char * const with_trace_name_param_name = "with-trace-name";

static
const char * const with_stream_class_name_param_name = "with-stream-class-name";

static
const char * const with_stream_name_param_name = "with-stream-name";

static
const char * const with_uuid_param_name = "with-uuid";

static
const char * const compact_param_name = "compact";

BT_HIDDEN
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;
}

BT_HIDDEN
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_SELF_COMPONENT_PORT_INPUT_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;
}

BT_HIDDEN
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
int configure_bool_opt(struct details_comp *details_comp,
		const bt_value *params, const char *param_name,
		bool default_value, bool *opt_value)
{
	int ret = 0;
	const bt_value *value;

	*opt_value = default_value;
	value = bt_value_map_borrow_entry_value_const(params, param_name);
	if (value) {
		if (!bt_value_is_bool(value)) {
			LOG_WRONG_PARAM_TYPE(param_name, value,
				BT_VALUE_TYPE_BOOL);
			ret = -1;
			goto end;
		}

		*opt_value = (bool) bt_value_bool_get(value);
	}

end:
	return ret;
}

static
int configure_details_comp(struct details_comp *details_comp,
		const bt_value *params)
{
	int ret = 0;
	const bt_value *value;
	const char *str;

	/* 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) {
		if (!bt_value_is_string(value)) {
			LOG_WRONG_PARAM_TYPE(color_param_name, value,
				BT_VALUE_TYPE_STRING);
			goto error;
		}

		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 if (strcmp(str, "always") == 0) {
			details_comp->cfg.with_color = true;
		} else {
			BT_COMP_LOGE("Invalid `%s` parameter: unknown value "
				"(expecting `never`, `auto`, or `always`): "
				"value=\"%s\"", color_param_name, str);
			goto error;
		}
	}

	/* With metadata objects? */
	ret = configure_bool_opt(details_comp, params, with_metadata_param_name,
		true, &details_comp->cfg.with_meta);
	if (ret) {
		goto error;
	}

	/* With data objects? */
	ret = configure_bool_opt(details_comp, params, with_data_param_name,
		true, &details_comp->cfg.with_data);
	if (ret) {
		goto error;
	}

	/* Compact? */
	ret = configure_bool_opt(details_comp, params, compact_param_name,
		false, &details_comp->cfg.compact);
	if (ret) {
		goto error;
	}

	/* With time? */
	ret = configure_bool_opt(details_comp, params, with_time_param_name,
		true, &details_comp->cfg.with_time);
	if (ret) {
		goto error;
	}

	/* With trace name? */
	ret = configure_bool_opt(details_comp, params,
		with_trace_name_param_name,
		true, &details_comp->cfg.with_trace_name);
	if (ret) {
		goto error;
	}

	/* With stream class name? */
	ret = configure_bool_opt(details_comp, params,
		with_stream_class_name_param_name,
		true, &details_comp->cfg.with_stream_class_name);
	if (ret) {
		goto error;
	}

	/* With stream name? */
	ret = configure_bool_opt(details_comp, params,
		with_stream_name_param_name,
		true, &details_comp->cfg.with_stream_name);
	if (ret) {
		goto error;
	}

	/* With UUID? */
	ret = configure_bool_opt(details_comp, params,
		with_uuid_param_name, true, &details_comp->cfg.with_uuid);
	if (ret) {
		goto error;
	}

	goto end;

error:
	ret = -1;

end:
	return ret;
}

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_HIDDEN
bt_component_class_init_method_status details_init(bt_self_component_sink *comp,
		const bt_value *params,
		__attribute__((unused)) void *init_method_data)
{
	bt_component_class_init_method_status status =
		BT_COMPONENT_CLASS_INIT_METHOD_STATUS_OK;
	bt_self_component_add_port_status add_port_status;
	struct details_comp *details_comp = NULL;

	add_port_status = bt_self_component_sink_add_input_port(comp,
		in_port_name, NULL, NULL);
	switch (add_port_status) {
	case BT_SELF_COMPONENT_ADD_PORT_STATUS_OK:
		status = BT_COMPONENT_CLASS_INIT_METHOD_STATUS_OK;
		break;
	case BT_SELF_COMPONENT_ADD_PORT_STATUS_ERROR:
		status = BT_COMPONENT_CLASS_INIT_METHOD_STATUS_ERROR;
		break;
	case BT_SELF_COMPONENT_ADD_PORT_STATUS_MEMORY_ERROR:
		status = BT_COMPONENT_CLASS_INIT_METHOD_STATUS_MEMORY_ERROR;
		break;
	default:
		abort();
	}

	details_comp = create_details_comp(comp);
	if (!details_comp) {
		status = BT_COMPONENT_CLASS_INIT_METHOD_STATUS_MEMORY_ERROR;
		goto error;
	}

	if (configure_details_comp(details_comp, params)) {
		BT_COMP_LOGE_STR("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:
	if (status == BT_COMPONENT_CLASS_INIT_METHOD_STATUS_OK) {
		status = BT_COMPONENT_CLASS_INIT_METHOD_STATUS_ERROR;
	}

	destroy_details_comp(details_comp);

end:
	return status;
}

BT_HIDDEN
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_self_component_port_input_message_iterator_create_from_sink_component_status
		msg_iter_status;
	bt_self_component_port_input_message_iterator *iterator;
	struct details_comp *details_comp;
	bt_self_component_port_input *in_port;

	details_comp = bt_self_component_get_data(
		bt_self_component_sink_as_self_component(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("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_self_component_port_input_message_iterator_create_from_sink_component(
		comp, bt_self_component_sink_borrow_input_port_by_name(comp,
			in_port_name), &iterator);
	if (msg_iter_status != BT_SELF_COMPONENT_PORT_INPUT_MESSAGE_ITERATOR_CREATE_FROM_SINK_COMPONENT_STATUS_OK) {
		status = (int) msg_iter_status;
		goto end;
	}

	BT_SELF_COMPONENT_PORT_INPUT_MESSAGE_ITERATOR_MOVE_REF(
		details_comp->msg_iter, iterator);

	status = BT_COMPONENT_CLASS_SINK_GRAPH_IS_CONFIGURED_METHOD_STATUS_OK;

end:
	return status;
}

BT_HIDDEN
bt_component_class_sink_consume_method_status
details_consume(bt_self_component_sink *comp)
{
	bt_component_class_sink_consume_method_status ret =
		BT_COMPONENT_CLASS_SINK_CONSUME_METHOD_STATUS_OK;
	bt_message_array_const msgs;
	uint64_t count;
	struct details_comp *details_comp;
	bt_message_iterator_next_status next_status;
	uint64_t i;

	details_comp = bt_self_component_get_data(
		bt_self_component_sink_as_self_component(comp));
	BT_ASSERT(details_comp);
	BT_ASSERT(details_comp->msg_iter);

	/* Consume messages */
	next_status = bt_self_component_port_input_message_iterator_next(
		details_comp->msg_iter, &msgs, &count);
	switch (next_status) {
	case BT_MESSAGE_ITERATOR_NEXT_STATUS_OK:
		ret = BT_COMPONENT_CLASS_SINK_CONSUME_METHOD_STATUS_OK;

		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]);
				}

				ret = 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]);
		}

		break;
	case BT_MESSAGE_ITERATOR_NEXT_STATUS_AGAIN:
		ret = BT_COMPONENT_CLASS_SINK_CONSUME_METHOD_STATUS_AGAIN;
		goto end;
	case BT_MESSAGE_ITERATOR_NEXT_STATUS_END:
		ret = BT_COMPONENT_CLASS_SINK_CONSUME_METHOD_STATUS_END;
		goto end;
	case BT_MESSAGE_ITERATOR_NEXT_STATUS_ERROR:
		ret = BT_COMPONENT_CLASS_SINK_CONSUME_METHOD_STATUS_ERROR;
		goto end;
	case BT_MESSAGE_ITERATOR_NEXT_STATUS_MEMORY_ERROR:
		ret = BT_COMPONENT_CLASS_SINK_CONSUME_METHOD_STATUS_MEMORY_ERROR;
		goto end;
	default:
		abort();
	}

end:
	return ret;
}
Commit	Line	Data
55478183 PP	1	/*
	2	* Copyright 2019 Philippe Proulx <pproulx@efficios.com>
	3	*
	4	* Permission is hereby granted, free of charge, to any person obtaining a copy
	5	* of this software and associated documentation files (the "Software"), to deal
	6	* in the Software without restriction, including without limitation the rights
	7	* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
	8	* copies of the Software, and to permit persons to whom the Software is
	9	* furnished to do so, subject to the following conditions:
	10	*
	11	* The above copyright notice and this permission notice shall be included in
	12	* all copies or substantial portions of the Software.
	13	*
	14	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	15	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	16	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
	17	* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	18	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
	19	* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
	20	* SOFTWARE.
	21	*/
	22
d400b9e6	23	#define BT_COMP_LOG_SELF_COMP (details_comp->self_comp)
6c868a3a	24	#define BT_LOG_OUTPUT_LEVEL (details_comp->log_level)
350ad6c1	25	#define BT_LOG_TAG "PLUGIN/SINK.TEXT.DETAILS"
d9c39b0a	26	#include "logging/comp-logging.h"
55478183 PP	27
	28	#include <babeltrace2/babeltrace.h>
	29
	30	#include "common/common.h"
	31	#include "common/assert.h"
	32	#include "details.h"
	33	#include "write.h"
	34
	35	#define LOG_WRONG_PARAM_TYPE(_name, _value, _exp_type) \
	36	do { \
d400b9e6	37	BT_COMP_LOGE("Wrong `%s` parameter type: type=%s, " \
55478183 PP	38	"expected-type=%s", \
	39	(_name), bt_common_value_type_string( \
	40	bt_value_get_type(_value)), \
	41	bt_common_value_type_string(_exp_type)); \
	42	} while (0)
	43
	44	static
	45	const char * const in_port_name = "in";
	46
	47	static
	48	const char * const color_param_name = "color";
	49
	50	static
	51	const char * const with_metadata_param_name = "with-metadata";
	52
cc413248 PP	53	static
	54	const char * const with_data_param_name = "with-data";
	55
55478183 PP	56	static
	57	const char * const with_time_param_name = "with-time";
	58
55478183 PP	59	static
	60	const char * const with_trace_name_param_name = "with-trace-name";
	61
	62	static
	63	const char * const with_stream_class_name_param_name = "with-stream-class-name";
	64
	65	static
	66	const char * const with_stream_name_param_name = "with-stream-name";
	67
	68	static
	69	const char * const with_uuid_param_name = "with-uuid";
	70
	71	static
	72	const char * const compact_param_name = "compact";
	73
	74	BT_HIDDEN
	75	void details_destroy_details_trace_class_meta(
	76	struct details_trace_class_meta *details_tc_meta)
	77	{
	78	if (!details_tc_meta) {
	79	goto end;
	80	}
	81
	82	if (details_tc_meta->objects) {
	83	g_hash_table_destroy(details_tc_meta->objects);
	84	details_tc_meta->objects = NULL;
	85	}
	86
	87	g_free(details_tc_meta);
	88
	89	end:
	90	return;
	91	}
	92
	93	BT_HIDDEN
	94	struct details_trace_class_meta *details_create_details_trace_class_meta(void)
	95	{
	96	struct details_trace_class_meta *details_tc_meta =
	97	g_new0(struct details_trace_class_meta, 1);
	98
	99	if (!details_tc_meta) {
	100	goto end;
	101	}
	102
	103	details_tc_meta->objects = g_hash_table_new(
	104	g_direct_hash, g_direct_equal);
	105	if (!details_tc_meta->objects) {
	106	details_destroy_details_trace_class_meta(details_tc_meta);
	107	details_tc_meta = NULL;
	108	goto end;
	109	}
	110
	111	details_tc_meta->tc_destruction_listener_id = UINT64_C(-1);
	112
	113	end:
	114	return details_tc_meta;
	115	}
	116
	117	static
	118	void destroy_details_comp(struct details_comp *details_comp)
	119	{
	120	GHashTableIter iter;
	121	gpointer key, value;
	122
123	if (!details_comp) {
124	goto end;
125	}
126
127	if (details_comp->meta) {
128	/*
129	* Remove trace class destruction listeners, because
130	* otherwise, when they are called, `details_comp`
131	* (their user data) won't exist anymore (we're
132	* destroying it here).
133	*/
134	g_hash_table_iter_init(&iter, details_comp->meta);
135
136	while (g_hash_table_iter_next(&iter, &key, &value)) {
137	struct details_trace_class_meta *details_tc_meta =
138	value;
139
140	if (details_tc_meta->tc_destruction_listener_id !=
141	UINT64_C(-1)) {
b80991f6 PP	142	if (bt_trace_class_remove_destruction_listener(
	143	(const void *) key,
	144	details_tc_meta->tc_destruction_listener_id)) {
	145	bt_current_thread_clear_error();
	146	}
55478183 PP	147	}
	148	}
	149
	150	g_hash_table_destroy(details_comp->meta);
	151	details_comp->meta = NULL;
	152	}
	153
	154	if (details_comp->traces) {
	155	/*
	156	* Remove trace destruction listeners, because
	157	* otherwise, when they are called, `details_comp` won't
	158	* exist anymore (we're destroying it here).
	159	*/
	160	g_hash_table_iter_init(&iter, details_comp->traces);
	161
	162	while (g_hash_table_iter_next(&iter, &key, &value)) {
	163	struct details_trace *details_trace = value;
	164
b80991f6 PP	165	if (bt_trace_remove_destruction_listener(
	166	(const void *) key,
	167	details_trace->trace_destruction_listener_id)) {
	168	bt_current_thread_clear_error();
	169	}
55478183 PP	170	}
	171
	172	g_hash_table_destroy(details_comp->traces);
	173	details_comp->traces = NULL;
	174	}
	175
	176	if (details_comp->str) {
	177	g_string_free(details_comp->str, TRUE);
	178	details_comp->str = NULL;
	179	}
	180
	181	BT_SELF_COMPONENT_PORT_INPUT_MESSAGE_ITERATOR_PUT_REF_AND_RESET(
	182	details_comp->msg_iter);
	183	g_free(details_comp);
	184
	185	end:
	186	return;
	187	}
	188
	189	static
6c868a3a PP	190	struct details_comp *create_details_comp(
6c868a3a PP	191	bt_self_component_sink *self_comp_sink)
55478183 PP	192	{
55478183 PP	193	struct details_comp *details_comp = g_new0(struct details_comp, 1);
6c868a3a PP	194	bt_self_component *self_comp =
6c868a3a PP	195	bt_self_component_sink_as_self_component(self_comp_sink);
55478183 PP	196
	197	if (!details_comp) {
	198	goto error;
	199	}
	200
6c868a3a PP	201	details_comp->log_level = bt_component_get_logging_level(
6c868a3a PP	202	bt_self_component_as_component(self_comp));
d400b9e6	203	details_comp->self_comp = self_comp;
55478183 PP	204	details_comp->meta = g_hash_table_new_full(g_direct_hash,
	205	g_direct_equal, NULL,
	206	(GDestroyNotify) details_destroy_details_trace_class_meta);
	207	if (!details_comp->meta) {
	208	goto error;
	209	}
	210
	211	details_comp->traces = g_hash_table_new_full(g_direct_hash,
	212	g_direct_equal, NULL, g_free);
	213	if (!details_comp->traces) {
	214	goto error;
	215	}
	216
	217	details_comp->str = g_string_new(NULL);
	218	if (!details_comp->str) {
	219	goto error;
	220	}
	221
	222	goto end;
	223
	224	error:
	225	destroy_details_comp(details_comp);
	226	details_comp = NULL;
	227
	228	end:
	229	return details_comp;
	230	}
	231
	232	BT_HIDDEN
	233	void details_finalize(bt_self_component_sink *comp)
	234	{
	235	struct details_comp *details_comp;
	236
	237	BT_ASSERT(comp);
	238	details_comp = bt_self_component_get_data(
	239	bt_self_component_sink_as_self_component(comp));
	240	BT_ASSERT(details_comp);
	241	destroy_details_comp(details_comp);
	242	}
	243
	244	static
	245	int configure_bool_opt(struct details_comp *details_comp,
	246	const bt_value params, const char param_name,
	247	bool default_value, bool *opt_value)
	248	{
	249	int ret = 0;
	250	const bt_value *value;
	251
	252	*opt_value = default_value;
	253	value = bt_value_map_borrow_entry_value_const(params, param_name);
	254	if (value) {
	255	if (!bt_value_is_bool(value)) {
	256	LOG_WRONG_PARAM_TYPE(param_name, value,
	257	BT_VALUE_TYPE_BOOL);
	258	ret = -1;
	259	goto end;
	260	}
	261
	262	*opt_value = (bool) bt_value_bool_get(value);
	263	}
	264
	265	end:
	266	return ret;
	267	}
268
269	static
270	int configure_details_comp(struct details_comp *details_comp,
271	const bt_value *params)
272	{
273	int ret = 0;
274	const bt_value *value;
275	const char *str;
276
277	/* Colorize output? */
278	details_comp->cfg.with_color = bt_common_colors_supported();
279	value = bt_value_map_borrow_entry_value_const(params, color_param_name);
280	if (value) {
281	if (!bt_value_is_string(value)) {
282	LOG_WRONG_PARAM_TYPE(color_param_name, value,
283	BT_VALUE_TYPE_STRING);
284	goto error;
285	}
286
287	str = bt_value_string_get(value);
288
289	if (strcmp(str, "never") == 0) {
290	details_comp->cfg.with_color = false;
291	} else if (strcmp(str, "auto") == 0) {
292	details_comp->cfg.with_color =
293	bt_common_colors_supported();
294	} else if (strcmp(str, "always") == 0) {
295	details_comp->cfg.with_color = true;
296	} else {
d400b9e6	297	BT_COMP_LOGE("Invalid `%s` parameter: unknown value "
55478183 PP	298	"(expecting `never`, `auto`, or `always`): "
	299	"value=\"%s\"", color_param_name, str);
	300	goto error;
	301	}
	302	}
	303
	304	/* With metadata objects? */
	305	ret = configure_bool_opt(details_comp, params, with_metadata_param_name,
	306	true, &details_comp->cfg.with_meta);
	307	if (ret) {
	308	goto error;
	309	}
	310
cc413248 PP	311	/* With data objects? */
	312	ret = configure_bool_opt(details_comp, params, with_data_param_name,
	313	true, &details_comp->cfg.with_data);
	314	if (ret) {
	315	goto error;
	316	}
	317
55478183 PP	318	/* Compact? */
	319	ret = configure_bool_opt(details_comp, params, compact_param_name,
	320	false, &details_comp->cfg.compact);
	321	if (ret) {
	322	goto error;
	323	}
	324
	325	/* With time? */
	326	ret = configure_bool_opt(details_comp, params, with_time_param_name,
	327	true, &details_comp->cfg.with_time);
	328	if (ret) {
	329	goto error;
	330	}
	331
55478183 PP	332	/* With trace name? */
	333	ret = configure_bool_opt(details_comp, params,
	334	with_trace_name_param_name,
	335	true, &details_comp->cfg.with_trace_name);
	336	if (ret) {
	337	goto error;
	338	}
	339
	340	/* With stream class name? */
	341	ret = configure_bool_opt(details_comp, params,
	342	with_stream_class_name_param_name,
	343	true, &details_comp->cfg.with_stream_class_name);
	344	if (ret) {
	345	goto error;
	346	}
	347
	348	/* With stream name? */
	349	ret = configure_bool_opt(details_comp, params,
	350	with_stream_name_param_name,
	351	true, &details_comp->cfg.with_stream_name);
	352	if (ret) {
	353	goto error;
	354	}
	355
	356	/* With UUID? */
	357	ret = configure_bool_opt(details_comp, params,
	358	with_uuid_param_name, true, &details_comp->cfg.with_uuid);
	359	if (ret) {
	360	goto error;
	361	}
	362
	363	goto end;
	364
	365	error:
	366	ret = -1;
	367
	368	end:
	369	return ret;
	370	}
	371
	372	static
	373	void log_configuration(bt_self_component_sink *comp,
	374	struct details_comp *details_comp)
	375	{
d400b9e6	376	BT_COMP_LOGI("Configuration for `sink.text.details` component `%s`:",
55478183 PP	377	bt_component_get_name(bt_self_component_as_component(
55478183 PP	378	bt_self_component_sink_as_self_component(comp))));
d400b9e6 PP	379	BT_COMP_LOGI(" Colorize output: %d", details_comp->cfg.with_color);
	380	BT_COMP_LOGI(" Compact: %d", details_comp->cfg.compact);
	381	BT_COMP_LOGI(" With metadata: %d", details_comp->cfg.with_meta);
	382	BT_COMP_LOGI(" With time: %d", details_comp->cfg.with_time);
d400b9e6 PP	383	BT_COMP_LOGI(" With trace name: %d", details_comp->cfg.with_trace_name);
d400b9e6 PP	384	BT_COMP_LOGI(" With stream class name: %d",
55478183	385	details_comp->cfg.with_stream_class_name);
d400b9e6 PP	386	BT_COMP_LOGI(" With stream name: %d", details_comp->cfg.with_stream_name);
d400b9e6 PP	387	BT_COMP_LOGI(" With UUID: %d", details_comp->cfg.with_uuid);
55478183 PP	388	}
	389
	390	BT_HIDDEN
d24d5663	391	bt_component_class_init_method_status details_init(bt_self_component_sink *comp,
55478183 PP	392	const bt_value *params,
	393	__attribute__((unused)) void *init_method_data)
	394	{
d24d5663 PP	395	bt_component_class_init_method_status status =
	396	BT_COMPONENT_CLASS_INIT_METHOD_STATUS_OK;
	397	bt_self_component_add_port_status add_port_status;
55478183 PP	398	struct details_comp *details_comp = NULL;
55478183 PP	399
d24d5663 PP	400	add_port_status = bt_self_component_sink_add_input_port(comp,
	401	in_port_name, NULL, NULL);
	402	switch (add_port_status) {
	403	case BT_SELF_COMPONENT_ADD_PORT_STATUS_OK:
	404	status = BT_COMPONENT_CLASS_INIT_METHOD_STATUS_OK;
	405	break;
	406	case BT_SELF_COMPONENT_ADD_PORT_STATUS_ERROR:
	407	status = BT_COMPONENT_CLASS_INIT_METHOD_STATUS_ERROR;
	408	break;
	409	case BT_SELF_COMPONENT_ADD_PORT_STATUS_MEMORY_ERROR:
	410	status = BT_COMPONENT_CLASS_INIT_METHOD_STATUS_MEMORY_ERROR;
	411	break;
	412	default:
	413	abort();
55478183 PP	414	}
55478183 PP	415
6c868a3a	416	details_comp = create_details_comp(comp);
55478183	417	if (!details_comp) {
d24d5663	418	status = BT_COMPONENT_CLASS_INIT_METHOD_STATUS_MEMORY_ERROR;
55478183 PP	419	goto error;
	420	}
	421
	422	if (configure_details_comp(details_comp, params)) {
d400b9e6	423	BT_COMP_LOGE_STR("Failed to configure component.");
55478183 PP	424	goto error;
	425	}
	426
	427	log_configuration(comp, details_comp);
	428	bt_self_component_set_data(
	429	bt_self_component_sink_as_self_component(comp), details_comp);
	430	goto end;
	431
	432	error:
d24d5663 PP	433	if (status == BT_COMPONENT_CLASS_INIT_METHOD_STATUS_OK) {
d24d5663 PP	434	status = BT_COMPONENT_CLASS_INIT_METHOD_STATUS_ERROR;
55478183 PP	435	}
	436
	437	destroy_details_comp(details_comp);
	438
	439	end:
	440	return status;
	441	}
	442
	443	BT_HIDDEN
d24d5663 PP	444	bt_component_class_sink_graph_is_configured_method_status
d24d5663 PP	445	details_graph_is_configured(bt_self_component_sink *comp)
55478183	446	{
e803df70 SM	447	bt_component_class_sink_graph_is_configured_method_status status;
	448	bt_self_component_port_input_message_iterator_create_from_sink_component_status
	449	msg_iter_status;
55478183 PP	450	bt_self_component_port_input_message_iterator *iterator;
	451	struct details_comp *details_comp;
	452	bt_self_component_port_input *in_port;
	453
	454	details_comp = bt_self_component_get_data(
	455	bt_self_component_sink_as_self_component(comp));
	456	BT_ASSERT(details_comp);
	457	in_port = bt_self_component_sink_borrow_input_port_by_name(comp,
	458	in_port_name);
	459	if (!bt_port_is_connected(bt_port_input_as_port_const(
	460	bt_self_component_port_input_as_port_input(in_port)))) {
d400b9e6	461	BT_COMP_LOGE("Single input port is not connected: "
55478183	462	"port-name=\"%s\"", in_port_name);
d24d5663	463	status = BT_COMPONENT_CLASS_SINK_GRAPH_IS_CONFIGURED_METHOD_STATUS_ERROR;
55478183 PP	464	goto end;
	465	}
	466
e803df70	467	msg_iter_status = bt_self_component_port_input_message_iterator_create_from_sink_component(
ca02df0a	468	comp, bt_self_component_sink_borrow_input_port_by_name(comp,
e803df70 SM	469	in_port_name), &iterator);
	470	if (msg_iter_status != BT_SELF_COMPONENT_PORT_INPUT_MESSAGE_ITERATOR_CREATE_FROM_SINK_COMPONENT_STATUS_OK) {
	471	status = (int) msg_iter_status;
55478183 PP	472	goto end;
	473	}
	474
	475	BT_SELF_COMPONENT_PORT_INPUT_MESSAGE_ITERATOR_MOVE_REF(
	476	details_comp->msg_iter, iterator);
	477
e803df70 SM	478	status = BT_COMPONENT_CLASS_SINK_GRAPH_IS_CONFIGURED_METHOD_STATUS_OK;
e803df70 SM	479
55478183 PP	480	end:
	481	return status;
	482	}
	483
	484	BT_HIDDEN
d24d5663 PP	485	bt_component_class_sink_consume_method_status
d24d5663 PP	486	details_consume(bt_self_component_sink *comp)
55478183	487	{
d24d5663 PP	488	bt_component_class_sink_consume_method_status ret =
d24d5663 PP	489	BT_COMPONENT_CLASS_SINK_CONSUME_METHOD_STATUS_OK;
55478183 PP	490	bt_message_array_const msgs;
	491	uint64_t count;
	492	struct details_comp *details_comp;
d24d5663	493	bt_message_iterator_next_status next_status;
55478183 PP	494	uint64_t i;
	495
	496	details_comp = bt_self_component_get_data(
	497	bt_self_component_sink_as_self_component(comp));
	498	BT_ASSERT(details_comp);
	499	BT_ASSERT(details_comp->msg_iter);
	500
	501	/* Consume messages */
d24d5663	502	next_status = bt_self_component_port_input_message_iterator_next(
55478183	503	details_comp->msg_iter, &msgs, &count);
d24d5663 PP	504	switch (next_status) {
	505	case BT_MESSAGE_ITERATOR_NEXT_STATUS_OK:
	506	ret = BT_COMPONENT_CLASS_SINK_CONSUME_METHOD_STATUS_OK;
55478183 PP	507
	508	for (i = 0; i < count; i++) {
	509	int print_ret = details_write_message(details_comp,
	510	msgs[i]);
	511
	512	if (print_ret) {
	513	for (; i < count; i++) {
	514	/* Put all remaining messages */
	515	bt_message_put_ref(msgs[i]);
	516	}
	517
d24d5663	518	ret = BT_COMPONENT_CLASS_SINK_CONSUME_METHOD_STATUS_ERROR;
55478183 PP	519	goto end;
	520	}
	521
	522	/* Print output buffer to standard output and flush */
	523	if (details_comp->str->len > 0) {
	524	printf("%s", details_comp->str->str);
	525	fflush(stdout);
	526	details_comp->printed_something = true;
	527	}
	528
	529	/* Put this message */
	530	bt_message_put_ref(msgs[i]);
	531	}
	532
	533	break;
d24d5663 PP	534	case BT_MESSAGE_ITERATOR_NEXT_STATUS_AGAIN:
d24d5663 PP	535	ret = BT_COMPONENT_CLASS_SINK_CONSUME_METHOD_STATUS_AGAIN;
55478183	536	goto end;
d24d5663 PP	537	case BT_MESSAGE_ITERATOR_NEXT_STATUS_END:
d24d5663 PP	538	ret = BT_COMPONENT_CLASS_SINK_CONSUME_METHOD_STATUS_END;
55478183	539	goto end;
d24d5663 PP	540	case BT_MESSAGE_ITERATOR_NEXT_STATUS_ERROR:
d24d5663 PP	541	ret = BT_COMPONENT_CLASS_SINK_CONSUME_METHOD_STATUS_ERROR;
55478183	542	goto end;
d24d5663 PP	543	case BT_MESSAGE_ITERATOR_NEXT_STATUS_MEMORY_ERROR:
d24d5663 PP	544	ret = BT_COMPONENT_CLASS_SINK_CONSUME_METHOD_STATUS_MEMORY_ERROR;
55478183 PP	545	goto end;
	546	default:
	547	abort();
	548	}
	549
	550	end:
	551	return ret;
	552	}