[babeltrace.git] / lib / plugin-system / component.c

/*
 * component.c
 *
 * Babeltrace Plugin Component
 *
 * Copyright 2015 Jérémie Galarneau <jeremie.galarneau@efficios.com>
 *
 * Author: Jérémie Galarneau <jeremie.galarneau@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.
 */

#include <babeltrace/plugin/component.h>
#include <babeltrace/plugin/component-internal.h>
#include <babeltrace/plugin/source-internal.h>
#include <babeltrace/plugin/filter-internal.h>
#include <babeltrace/plugin/notification/iterator-internal.h>
#include <babeltrace/plugin/sink-internal.h>
#include <babeltrace/babeltrace-internal.h>
#include <babeltrace/compiler.h>
#include <babeltrace/ref.h>

static
struct bt_component * (* const component_create_funcs[])(
		struct bt_component_class *, struct bt_value *) = {
	[BT_COMPONENT_TYPE_SOURCE] = bt_component_source_create,
	[BT_COMPONENT_TYPE_SINK] = bt_component_sink_create,
	[BT_COMPONENT_TYPE_FILTER] = bt_component_filter_create,
};

static
enum bt_component_status (* const component_validation_funcs[])(
		struct bt_component *) = {
	[BT_COMPONENT_TYPE_SOURCE] = bt_component_source_validate,
	[BT_COMPONENT_TYPE_SINK] = bt_component_sink_validate,
	[BT_COMPONENT_TYPE_FILTER] = bt_component_filter_validate,
};

static
void bt_component_destroy(struct bt_object *obj)
{
	struct bt_component *component = NULL;
	struct bt_component_class *component_class = NULL;

	if (!obj) {
		return;
	}

	component = container_of(obj, struct bt_component, base);
	component_class = component->class;

	/*
	 * User data is destroyed first, followed by the concrete component
	 * instance.
	 */
	if (component->user_destroy) {
		component->user_destroy(component);
	}

	if (component->destroy) {
		component->destroy(component);
	}

	g_string_free(component->name, TRUE);
	bt_put(component_class);
	g_free(component);
}

BT_HIDDEN
enum bt_component_status bt_component_init(struct bt_component *component,
		bt_component_destroy_cb destroy)
{
	enum bt_component_status ret = BT_COMPONENT_STATUS_OK;

	if (!component) {
		ret = BT_COMPONENT_STATUS_INVALID;
		goto end;
	}

	component->destroy = destroy;
end:
	return ret;
}

BT_HIDDEN
enum bt_component_type bt_component_get_type(struct bt_component *component)
{
	return component ? component->class->type : BT_COMPONENT_TYPE_UNKNOWN;
}

BT_HIDDEN
struct bt_notification_iterator *bt_component_create_iterator(
		struct bt_component *component)
{
	enum bt_notification_iterator_status ret_iterator;
	enum bt_component_type component_type;
	struct bt_notification_iterator *iterator = NULL;

	if (!component) {
		goto error;
	}

	component_type = bt_component_get_type(component);
	if (component_type != BT_COMPONENT_TYPE_SOURCE &&
			component_type != BT_COMPONENT_TYPE_FILTER) {
		/* Unsupported operation. */
		goto error;
	}

	iterator = bt_notification_iterator_create(component);
	if (!iterator) {
		goto error;
	}

	switch (component_type) {
	case BT_COMPONENT_TYPE_SOURCE:
	{
		struct bt_component_source *source;
		enum bt_component_status ret_component;

		source = container_of(component, struct bt_component_source, parent);
		assert(source->init_iterator);
		ret_component = source->init_iterator(component, iterator);
		if (ret_component != BT_COMPONENT_STATUS_OK) {
			goto error;
		}
		break;

		break;
	}
	case BT_COMPONENT_TYPE_FILTER:
	{
		struct bt_component_filter *filter;
		enum bt_component_status ret_component;

		filter = container_of(component, struct bt_component_filter, parent);
		assert(filter->init_iterator);
		ret_component = filter->init_iterator(component, iterator);
		if (ret_component != BT_COMPONENT_STATUS_OK) {
			goto error;
		}
		break;
	}
	default:
		/* Unreachable. */
		assert(0);
	}

	ret_iterator = bt_notification_iterator_validate(iterator);
	if (ret_iterator != BT_NOTIFICATION_ITERATOR_STATUS_OK) {
		goto error;
	}

	return iterator;
error:
	BT_PUT(iterator);
	return iterator;
}

struct bt_component *bt_component_create(
		struct bt_component_class *component_class, const char *name,
		struct bt_value *params)
{
	int ret;
	struct bt_component *component = NULL;
	enum bt_component_type type;

	if (!component_class) {
		goto end;
	}

	type = bt_component_class_get_type(component_class);
	if (type <= BT_COMPONENT_TYPE_UNKNOWN ||
			type > BT_COMPONENT_TYPE_FILTER) {
		goto end;
	}

	component = component_create_funcs[type](component_class, params);
	if (!component) {
		goto end;
	}

	bt_object_init(component, bt_component_destroy);
	component->name = g_string_new(name);
	if (!component->name) {
		BT_PUT(component);
		goto end;
	}

	component->initializing = true;
	ret = component_class->init(component, params);
	component->initializing = false;
	if (ret != BT_COMPONENT_STATUS_OK) {
		BT_PUT(component);
		goto end;
	}
	ret = component_validation_funcs[type](component);
	if (ret != BT_COMPONENT_STATUS_OK) {
		BT_PUT(component);
		goto end;
	}
end:
	return component;
}

const char *bt_component_get_name(struct bt_component *component)
{
	const char *ret = NULL;

	if (!component) {
		goto end;
	}

	ret = component->name->str;
end:
	return ret;
}

enum bt_component_status bt_component_set_name(struct bt_component *component,
		const char *name)
{
	enum bt_component_status ret = BT_COMPONENT_STATUS_OK;

	if (!component || !name || name[0] == '\0') {
		ret = BT_COMPONENT_STATUS_INVALID;
		goto end;
	}

	g_string_assign(component->name, name);
end:
	return ret;
}

struct bt_component_class *bt_component_get_class(
		struct bt_component *component)
{
	return component ? bt_get(component->class) : NULL;
}

void *bt_component_get_private_data(struct bt_component *component)
{
	return component ? component->user_data : NULL;
}

enum bt_component_status
bt_component_set_private_data(struct bt_component *component,
		void *data)
{
	enum bt_component_status ret = BT_COMPONENT_STATUS_OK;

	if (!component || !component->initializing) {
		ret = BT_COMPONENT_STATUS_INVALID;
		goto end;
	}

	component->user_data = data;
end:
	return ret;
}

enum bt_component_status bt_component_set_destroy_cb(
		struct bt_component *component, bt_component_destroy_cb destroy)
{
	enum bt_component_status ret = BT_COMPONENT_STATUS_OK;

	if (!component || !component->initializing) {
		ret = BT_COMPONENT_STATUS_INVALID;
		goto end;
	}

	component->user_destroy = destroy;
end:
	return ret;
}
Commit	Line	Data
de713ce0 JG	1	/*
	2	* component.c
	3	*
	4	* Babeltrace Plugin Component
	5	*
	6	* Copyright 2015 Jérémie Galarneau <jeremie.galarneau@efficios.com>
	7	*
	8	* Author: Jérémie Galarneau <jeremie.galarneau@efficios.com>
	9	*
	10	* Permission is hereby granted, free of charge, to any person obtaining a copy
	11	* of this software and associated documentation files (the "Software"), to deal
	12	* in the Software without restriction, including without limitation the rights
	13	* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
	14	* copies of the Software, and to permit persons to whom the Software is
	15	* furnished to do so, subject to the following conditions:
	16	*
	17	* The above copyright notice and this permission notice shall be included in
	18	* all copies or substantial portions of the Software.
	19	*
	20	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	21	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	22	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
	23	* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	24	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
	25	* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
	26	* SOFTWARE.
	27	*/
	28
47e5a032	29	#include <babeltrace/plugin/component.h>
de713ce0	30	#include <babeltrace/plugin/component-internal.h>
38b48196	31	#include <babeltrace/plugin/source-internal.h>
5645cd95 JG	32	#include <babeltrace/plugin/filter-internal.h>
5645cd95 JG	33	#include <babeltrace/plugin/notification/iterator-internal.h>
38b48196	34	#include <babeltrace/plugin/sink-internal.h>
de713ce0 JG	35	#include <babeltrace/babeltrace-internal.h>
de713ce0 JG	36	#include <babeltrace/compiler.h>
b8a06801	37	#include <babeltrace/ref.h>
de713ce0	38
7c7c0433 JG	39	static
	40	struct bt_component * (* const component_create_funcs[])(
	41	struct bt_component_class , struct bt_value ) = {
	42	[BT_COMPONENT_TYPE_SOURCE] = bt_component_source_create,
	43	[BT_COMPONENT_TYPE_SINK] = bt_component_sink_create,
11b27444	44	[BT_COMPONENT_TYPE_FILTER] = bt_component_filter_create,
7c7c0433 JG	45	};
	46
	47	static
	48	enum bt_component_status (* const component_validation_funcs[])(
	49	struct bt_component *) = {
	50	[BT_COMPONENT_TYPE_SOURCE] = bt_component_source_validate,
	51	[BT_COMPONENT_TYPE_SINK] = bt_component_sink_validate,
11b27444	52	[BT_COMPONENT_TYPE_FILTER] = bt_component_filter_validate,
7c7c0433 JG	53	};
7c7c0433 JG	54
b8a06801 JG	55	static
	56	void bt_component_destroy(struct bt_object *obj)
	57	{
	58	struct bt_component *component = NULL;
	59	struct bt_component_class *component_class = NULL;
	60
	61	if (!obj) {
	62	return;
	63	}
	64
	65	component = container_of(obj, struct bt_component, base);
7c7c0433 JG	66	component_class = component->class;
	67
	68	/*
b8a06801 JG	69	* User data is destroyed first, followed by the concrete component
	70	* instance.
	71	*/
7c7c0433	72	if (component->user_destroy) {
760051fa	73	component->user_destroy(component);
7c7c0433	74	}
b8a06801	75
ab09f844 JG	76	if (component->destroy) {
	77	component->destroy(component);
	78	}
	79
7c7c0433	80	g_string_free(component->name, TRUE);
b8a06801	81	bt_put(component_class);
7c7c0433	82	g_free(component);
b8a06801 JG	83	}
	84
	85	BT_HIDDEN
	86	enum bt_component_status bt_component_init(struct bt_component *component,
b8a06801 JG	87	bt_component_destroy_cb destroy)
	88	{
	89	enum bt_component_status ret = BT_COMPONENT_STATUS_OK;
	90
ab09f844	91	if (!component) {
30d619df	92	ret = BT_COMPONENT_STATUS_INVALID;
b8a06801 JG	93	goto end;
	94	}
	95
b8a06801 JG	96	component->destroy = destroy;
	97	end:
	98	return ret;
	99	}
de713ce0	100
38b48196 JG	101	BT_HIDDEN
	102	enum bt_component_type bt_component_get_type(struct bt_component *component)
	103	{
	104	return component ? component->class->type : BT_COMPONENT_TYPE_UNKNOWN;
	105	}
	106
5645cd95 JG	107	BT_HIDDEN
	108	struct bt_notification_iterator *bt_component_create_iterator(
	109	struct bt_component *component)
	110	{
	111	enum bt_notification_iterator_status ret_iterator;
	112	enum bt_component_type component_type;
	113	struct bt_notification_iterator *iterator = NULL;
	114
	115	if (!component) {
	116	goto error;
	117	}
	118
	119	component_type = bt_component_get_type(component);
	120	if (component_type != BT_COMPONENT_TYPE_SOURCE &&
	121	component_type != BT_COMPONENT_TYPE_FILTER) {
	122	/* Unsupported operation. */
	123	goto error;
	124	}
	125
	126	iterator = bt_notification_iterator_create(component);
	127	if (!iterator) {
	128	goto error;
	129	}
	130
	131	switch (component_type) {
	132	case BT_COMPONENT_TYPE_SOURCE:
	133	{
	134	struct bt_component_source *source;
	135	enum bt_component_status ret_component;
	136
	137	source = container_of(component, struct bt_component_source, parent);
	138	assert(source->init_iterator);
	139	ret_component = source->init_iterator(component, iterator);
	140	if (ret_component != BT_COMPONENT_STATUS_OK) {
	141	goto error;
	142	}
	143	break;
	144
	145	break;
	146	}
	147	case BT_COMPONENT_TYPE_FILTER:
	148	{
	149	struct bt_component_filter *filter;
	150	enum bt_component_status ret_component;
	151
	152	filter = container_of(component, struct bt_component_filter, parent);
	153	assert(filter->init_iterator);
	154	ret_component = filter->init_iterator(component, iterator);
	155	if (ret_component != BT_COMPONENT_STATUS_OK) {
	156	goto error;
	157	}
	158	break;
	159	}
	160	default:
	161	/* Unreachable. */
	162	assert(0);
	163	}
	164
	165	ret_iterator = bt_notification_iterator_validate(iterator);
	166	if (ret_iterator != BT_NOTIFICATION_ITERATOR_STATUS_OK) {
	167	goto error;
	168	}
	169
	170	return iterator;
171	error:
172	BT_PUT(iterator);
173	return iterator;
174	}
175
38b48196	176	struct bt_component *bt_component_create(
7c7c0433 JG	177	struct bt_component_class component_class, const char name,
7c7c0433 JG	178	struct bt_value *params)
38b48196	179	{
7c7c0433	180	int ret;
38b48196	181	struct bt_component *component = NULL;
7c7c0433	182	enum bt_component_type type;
38b48196 JG	183
	184	if (!component_class) {
	185	goto end;
	186	}
	187
7c7c0433 JG	188	type = bt_component_class_get_type(component_class);
7c7c0433 JG	189	if (type <= BT_COMPONENT_TYPE_UNKNOWN \|\|
11b27444	190	type > BT_COMPONENT_TYPE_FILTER) {
7c7c0433 JG	191	goto end;
	192	}
	193
	194	component = component_create_funcs[type](component_class, params);
	195	if (!component) {
	196	goto end;
	197	}
	198
	199	bt_object_init(component, bt_component_destroy);
7c7c0433	200	component->name = g_string_new(name);
4b70dd83	201	if (!component->name) {
7c7c0433 JG	202	BT_PUT(component);
	203	goto end;
	204	}
	205
fec2a9f2	206	component->initializing = true;
528debdf	207	ret = component_class->init(component, params);
fec2a9f2	208	component->initializing = false;
528debdf MD	209	if (ret != BT_COMPONENT_STATUS_OK) {
	210	BT_PUT(component);
	211	goto end;
	212	}
7c7c0433	213	ret = component_validation_funcs[type](component);
692b38d2	214	if (ret != BT_COMPONENT_STATUS_OK) {
7c7c0433	215	BT_PUT(component);
38b48196 JG	216	goto end;
	217	}
	218	end:
	219	return component;
	220	}
	221
de713ce0 JG	222	const char bt_component_get_name(struct bt_component component)
	223	{
	224	const char *ret = NULL;
	225
	226	if (!component) {
	227	goto end;
	228	}
	229
	230	ret = component->name->str;
	231	end:
	232	return ret;
	233	}
	234
	235	enum bt_component_status bt_component_set_name(struct bt_component *component,
	236	const char *name)
	237	{
	238	enum bt_component_status ret = BT_COMPONENT_STATUS_OK;
	239
	240	if (!component \|\| !name \|\| name[0] == '\0') {
30d619df	241	ret = BT_COMPONENT_STATUS_INVALID;
de713ce0 JG	242	goto end;
	243	}
	244
	245	g_string_assign(component->name, name);
	246	end:
	247	return ret;
	248	}
	249
38b48196 JG	250	struct bt_component_class *bt_component_get_class(
38b48196 JG	251	struct bt_component *component)
de713ce0	252	{
38b48196	253	return component ? bt_get(component->class) : NULL;
de713ce0 JG	254	}
de713ce0 JG	255
de713ce0 JG	256	void bt_component_get_private_data(struct bt_component component)
de713ce0 JG	257	{
38b48196	258	return component ? component->user_data : NULL;
de713ce0 JG	259	}
	260
	261	enum bt_component_status
	262	bt_component_set_private_data(struct bt_component *component,
	263	void *data)
	264	{
	265	enum bt_component_status ret = BT_COMPONENT_STATUS_OK;
	266
fec2a9f2	267	if (!component \|\| !component->initializing) {
30d619df	268	ret = BT_COMPONENT_STATUS_INVALID;
de713ce0 JG	269	goto end;
	270	}
	271
	272	component->user_data = data;
	273	end:
	274	return ret;
	275	}
42d7dce5 JG	276
	277	enum bt_component_status bt_component_set_destroy_cb(
	278	struct bt_component *component, bt_component_destroy_cb destroy)
	279	{
	280	enum bt_component_status ret = BT_COMPONENT_STATUS_OK;
	281
fec2a9f2	282	if (!component \|\| !component->initializing) {
42d7dce5 JG	283	ret = BT_COMPONENT_STATUS_INVALID;
	284	goto end;
	285	}
	286
	287	component->user_destroy = destroy;
	288	end:
	289	return ret;
	290	}