metababel 0.0.0

data/template/filter.c.erb

@@ -0,0 +1,400 @@
+#include "uthash.h"
+#include "utlist.h"
+#include <babeltrace2/babeltrace.h>
+#include <metababel/metababel.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+/* Loosely inspired by
+ * https://babeltrace.org/docs/v2.0/libbabeltrace2/example-simple-flt-cmp-cls.html
+ */
+
+static const char *get_port_name(uint64_t current) {
+  int num_len = snprintf(NULL, 0, "in%ld", current);
+  char *result = (char *)malloc(num_len + 1);
+  sprintf(result, "in%ld", current);
+  return result;
+}
+
+/*
+ *  Handle Upstream Messages
+ */
+
+static inline bt_message_iterator_class_next_method_status
+filter_message_iterator_next_initializing(
+    bt_self_message_iterator *self_message_iterator,
+    bt_message_array_const messages, uint64_t capacity, uint64_t *count) {
+  /* Retrieve our private data from the message iterator's user data */
+  btx_message_iterator_t *message_iterator_private_data =
+      bt_self_message_iterator_get_data(self_message_iterator);
+
+  /* Call Initialize user callback */
+  btx_call_callbacks_initialize_usr_data(
+      message_iterator_private_data->common_data,
+      &message_iterator_private_data->common_data->usr_data);
+  /* Call read callbacks */
+  btx_call_callbacks_read_params(
+      message_iterator_private_data->common_data,
+      message_iterator_private_data->common_data->usr_data,
+      message_iterator_private_data->common_data->btx_params);
+
+  // We need to transition in the procesing state
+  message_iterator_private_data->state = BTX_FILTER_STATE_PROCESSING;
+  if (message_iterator_private_data->queue)
+    message_iterator_private_data->processing_state =
+        BTX_FILTER_PROCESSING_STATE_SENDING;
+
+  return BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_AGAIN;
+}
+
+static inline bt_message_iterator_class_next_method_status
+filter_message_iterator_next_processing_sending(
+    bt_self_message_iterator *self_message_iterator,
+    bt_message_array_const messages, uint64_t capacity, uint64_t *count) {
+  /* Retrieve our private data from the message iterator's user data */
+  btx_message_iterator_t *message_iterator_private_data =
+      bt_self_message_iterator_get_data(self_message_iterator);
+
+  btx_downstream_move_messages(message_iterator_private_data, messages,
+                               capacity, count);
+
+  if (!message_iterator_private_data->queue) {
+    message_iterator_private_data->processing_state =
+        BTX_FILTER_PROCESSING_STATE_READING;
+  }
+  return BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_OK;
+}
+
+static inline bt_message_iterator_class_next_method_status
+filter_message_iterator_next_processing_reading(
+    bt_self_message_iterator *self_message_iterator,
+    bt_message_array_const messages, uint64_t capacity, uint64_t *count) {
+  /* Retrieve our private data from the message iterator's user data */
+  btx_message_iterator_t *message_iterator_private_data =
+      bt_self_message_iterator_get_data(self_message_iterator);
+
+  common_data_t *common_data = message_iterator_private_data->common_data;
+
+  /* Consume a batch of messages from the upstream message iterator */
+  uint64_t upstream_message_count;
+  bt_message_array_const upstream_messages;
+
+  bt_message_iterator_next_status next_status = bt_message_iterator_next(
+      message_iterator_private_data->head_mi->message_iterator,
+      &upstream_messages, &upstream_message_count);
+
+  /* We cannot have any message left in the downstream queue
+   * Hence it's safe to pass any error messages downstream.
+   */
+  switch (next_status) {
+  case BT_MESSAGE_ITERATOR_NEXT_STATUS_END:
+    /* We are setting the state, so this function will never being call twice */
+    bt_message_iterator_put_ref(
+        message_iterator_private_data->head_mi->message_iterator);
+
+    CDL_DELETE(message_iterator_private_data->head_mi,
+               message_iterator_private_data->head_mi);
+    if (!message_iterator_private_data->head_mi) {
+      /* Call Finalize user callback */
+      btx_call_callbacks_finalize_usr_data(
+          message_iterator_private_data->common_data,
+          message_iterator_private_data->common_data->usr_data);
+      message_iterator_private_data->state = BTX_FILTER_STATE_FINALIZING;
+      message_iterator_private_data->processing_state =
+          BTX_FILTER_PROCESSING_STATE_FINISHED;
+    }
+    return BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_AGAIN;
+  case BT_MESSAGE_ITERATOR_NEXT_STATUS_AGAIN:
+    return BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_AGAIN;
+  case BT_MESSAGE_ITERATOR_NEXT_STATUS_MEMORY_ERROR:
+    message_iterator_private_data->state = BTX_FILTER_STATE_ERROR;
+    return BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_MEMORY_ERROR;
+  case BT_MESSAGE_ITERATOR_NEXT_STATUS_ERROR:
+    message_iterator_private_data->state = BTX_FILTER_STATE_ERROR;
+    return BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_ERROR;
+  case BT_MESSAGE_ITERATOR_NEXT_STATUS_OK:
+    break;
+  default:
+    message_iterator_private_data->state = BTX_FILTER_STATE_ERROR;
+    return BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_ERROR;
+  }
+
+  /* For each consumed message */
+  for (uint64_t upstream_i = 0; upstream_i < upstream_message_count;
+       upstream_i++) {
+    /* Current message */
+    const bt_message *upstream_message = upstream_messages[upstream_i];
+    /* Move as is if it's not an event message */
+    if (bt_message_get_type(upstream_message) != BT_MESSAGE_TYPE_EVENT) {
+      bt_message_put_ref(upstream_message);
+      continue;
+    }
+    /* Borrow the event message's event and its class */
+    const bt_event *event =
+        bt_message_event_borrow_event_const(upstream_message);
+    const bt_event_class *event_class = bt_event_borrow_class_const(event);
+
+    /* Call dispatcher or forward message downstream */
+    name_to_dispatcher_t *s = NULL;
+    const char *class_name = bt_event_class_get_name(event_class);
+    HASH_FIND_STR(common_data->name_to_dispatcher, class_name, s);
+    if (s) {
+      (*((dispatcher_t(*))(s->dispatcher)))(s->callbacks, common_data, event);
+      /* The message have been consumed, we can discard it */
+      bt_message_put_ref(upstream_message);
+    } else {
+      btx_downstream_push_message(message_iterator_private_data,
+                                  upstream_message);
+    }
+  }
+
+  /* Round Robin between Upstream MessageIterator */
+  message_iterator_private_data->head_mi =
+      message_iterator_private_data->head_mi->next;
+
+  if (message_iterator_private_data->queue) {
+    message_iterator_private_data->processing_state =
+        BTX_FILTER_PROCESSING_STATE_SENDING;
+    /* optimization */
+    return filter_message_iterator_next_processing_sending(
+        self_message_iterator, messages, capacity, count);
+  } else
+    return BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_AGAIN;
+}
+
+static inline bt_message_iterator_class_next_method_status
+filter_message_iterator_next_processing(
+    bt_self_message_iterator *self_message_iterator,
+    bt_message_array_const messages, uint64_t capacity, uint64_t *count) {
+  /* Retrieve our private data from the message iterator's user data */
+  btx_message_iterator_t *message_iterator_private_data =
+      bt_self_message_iterator_get_data(self_message_iterator);
+
+  switch (message_iterator_private_data->processing_state) {
+  case BTX_FILTER_PROCESSING_STATE_READING:
+    return filter_message_iterator_next_processing_reading(
+        self_message_iterator, messages, capacity, count);
+  case BTX_FILTER_PROCESSING_STATE_SENDING:
+    return filter_message_iterator_next_processing_sending(
+        self_message_iterator, messages, capacity, count);
+  case BTX_FILTER_PROCESSING_STATE_FINISHED:
+    return BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_ERROR;
+  default:
+    return BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_ERROR;
+  }
+}
+
+static inline bt_message_iterator_class_next_method_status
+filter_message_iterator_next_finalizing(
+    bt_self_message_iterator *self_message_iterator,
+    bt_message_array_const messages, uint64_t capacity, uint64_t *count) {
+  /* Retrieve our private data from the message iterator's user data */
+  btx_message_iterator_t *message_iterator_private_data =
+      bt_self_message_iterator_get_data(self_message_iterator);
+
+  // assert(message_iterator_private_data->processing_state ==
+  // BTX_FILTER_PROCESSING_STATE_FINISHED);
+  if (!message_iterator_private_data->queue) {
+    message_iterator_private_data->state = BTX_FILTER_STATE_FINISHED;
+    return BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_END;
+  }
+
+  btx_downstream_move_messages(message_iterator_private_data, messages,
+                               capacity, count);
+  return BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_OK;
+}
+
+static bt_message_iterator_class_next_method_status
+filter_message_iterator_next(bt_self_message_iterator *self_message_iterator,
+                             bt_message_array_const messages, uint64_t capacity,
+                             uint64_t *count) {
+
+  /* Retrieve our private data from the message iterator's user data */
+  btx_message_iterator_t *message_iterator_private_data =
+      bt_self_message_iterator_get_data(self_message_iterator);
+
+  switch (message_iterator_private_data->state) {
+  case BTX_FILTER_STATE_INITIALIZING:
+    return filter_message_iterator_next_initializing(self_message_iterator,
+                                                     messages, capacity, count);
+  case BTX_FILTER_STATE_PROCESSING:
+    return filter_message_iterator_next_processing(self_message_iterator,
+                                                   messages, capacity, count);
+  case BTX_FILTER_STATE_FINALIZING:
+    return filter_message_iterator_next_finalizing(self_message_iterator,
+                                                   messages, capacity, count);
+  case BTX_FILTER_STATE_FINISHED:
+    return BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_END;
+  default:
+    return BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_ERROR;
+  }
+}
+
+/*
+ * Initializes the filter component.
+ */
+static bt_component_class_initialize_method_status
+filter_initialize(bt_self_component_filter *self_component_filter,
+                  bt_self_component_filter_configuration *configuration,
+                  const bt_value *params, void *initialize_method_data) {
+
+  /* Allocate a private data structure */
+  common_data_t *common_data = calloc(1, sizeof(common_data_t));
+  common_data->params = params;
+  // Read parameters
+  btx_populate_params(common_data);
+  bt_value_get_ref(common_data->params);
+
+  /* Register User Callbacks */
+  btx_register_usr_callbacks((void *)common_data);
+
+  /* Set the component's user data to our private data structure */
+  bt_self_component_set_data(
+      bt_self_component_filter_as_self_component(self_component_filter),
+      common_data);
+
+  /*
+   * Add an input port named `in` to the filter component.
+   *
+   * This is needed so that this filter component can be connected to
+   * a filter or a source component. With a connected upstream
+   * component, this filter component's message iterator can create a
+   * message iterator to consume messages.
+   *
+   * Add an output port named `out` to the filter component.
+   *
+   * This is needed so that this filter component can be connected to
+   * a filter or a sink component. Once a downstream component is
+   * connected, it can create our message iterator.
+   */
+
+  common_data->component =
+      bt_self_component_filter_as_component_filter(self_component_filter);
+
+  const uint64_t current =
+      bt_component_filter_get_input_port_count(common_data->component);
+
+  bt_self_component_filter_add_input_port(self_component_filter,
+                                          get_port_name(current), NULL, NULL);
+
+  bt_self_component_filter_add_output_port(self_component_filter, "out", NULL,
+                                           NULL);
+
+  /* Create message that will be used by the filter */
+  bt_self_component *self_component =
+      bt_self_component_filter_as_self_component(self_component_filter);
+  /* Create a `trace_class` and all the children classes (stream and events) */
+  bt_trace_class *trace_class =
+      btx_downstream_trace_class_create_rec(self_component);
+  /* Instantiate a `downstream_trace` of `trace_class` and all the children
+   * stream */
+  common_data->downstream_trace = btx_downstream_trace_create_rec(trace_class);
+  return BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_OK;
+}
+
+bt_component_class_port_connected_method_status
+filter_input_port_connected(bt_self_component_filter *self_comp,
+                            bt_self_component_port_input *self_port,
+                            const bt_port_output *other_port) {
+  const uint64_t current = bt_component_filter_get_input_port_count(
+      bt_self_component_filter_as_component_filter(self_comp));
+  bt_self_component_filter_add_input_port(self_comp, get_port_name(current),
+                                          NULL, NULL);
+  return BT_COMPONENT_CLASS_PORT_CONNECTED_METHOD_STATUS_OK;
+}
+/*
+ * Initializes the message iterator.
+ */
+static bt_message_iterator_class_initialize_method_status
+filter_message_iterator_initialize(
+    bt_self_message_iterator *self_message_iterator,
+    bt_self_message_iterator_configuration *configuration,
+    bt_self_component_port_output *self_port) {
+  /* Allocate a private data structure */
+  btx_message_iterator_t *message_iterator_private_data =
+      calloc(1, sizeof(btx_message_iterator_t));
+
+  /* Retrieve the component's private data from its user data */
+  common_data_t *common_data = bt_self_component_get_data(
+      bt_self_message_iterator_borrow_component(self_message_iterator));
+
+  /* Save a link to the self_message_iterator */
+  common_data->self_message_iterator = self_message_iterator;
+
+  /* Keep a link to the component's private data */
+  message_iterator_private_data->common_data = common_data;
+
+  /* Create the upstream message iterators */
+  for (uint64_t i = 0;
+       i < bt_component_filter_get_input_port_count(common_data->component);
+       i++) {
+    bt_self_component_port_input *self_port =
+        bt_self_component_filter_borrow_input_port_by_index(
+            (bt_self_component_filter *)common_data->component, i);
+
+    const bt_port *port = bt_self_component_port_as_port(
+        bt_self_component_port_input_as_self_component_port(self_port));
+
+    /* Skip non-connected port */
+    if (!bt_port_is_connected(port))
+      continue;
+
+    el_mi *mi = (el_mi *)malloc(sizeof *mi);
+    bt_message_iterator_create_from_message_iterator(
+        self_message_iterator, self_port, &mi->message_iterator);
+    CDL_APPEND(message_iterator_private_data->head_mi, mi);
+  }
+
+  /* Set the message iterator's user data to our private data structure */
+  bt_self_message_iterator_set_data(self_message_iterator,
+                                    message_iterator_private_data);
+
+  message_iterator_private_data->state = BTX_FILTER_STATE_INITIALIZING;
+  message_iterator_private_data->processing_state =
+      BTX_FILTER_PROCESSING_STATE_READING;
+
+  return BT_MESSAGE_ITERATOR_CLASS_INITIALIZE_METHOD_STATUS_OK;
+}
+
+static void filter_finalize(bt_self_component_filter *self_component_filter) {
+  common_data_t *common_data = bt_self_component_get_data(
+      bt_self_component_filter_as_self_component(self_component_filter));
+  // We allocate it, we need to free it
+  free(common_data->btx_params);
+  bt_value_put_ref(common_data->params);
+  free(common_data);
+}
+
+static void filter_message_iterator_finalize(
+    bt_self_message_iterator *self_message_iterator) {
+  /* Retrieve our private data from the message iterator's user data */
+  btx_message_iterator_t *message_iterator_private_data =
+      bt_self_message_iterator_get_data(self_message_iterator);
+
+  struct el *elt, *tmp;
+  DL_FOREACH_SAFE(message_iterator_private_data->pool, elt, tmp) {
+    DL_DELETE(message_iterator_private_data->pool, elt);
+    free(elt);
+  }
+
+  /* Free the allocated structure */
+  free(message_iterator_private_data);
+}
+
+/* Mandatory */
+BT_PLUGIN_MODULE();
+
+BT_PLUGIN(<%= options[:plugin_name] %>);
+BT_PLUGIN_FILTER_COMPONENT_CLASS(<%= options[:component_name] %>,
+                                 filter_message_iterator_next);
+
+BT_PLUGIN_FILTER_COMPONENT_CLASS_INITIALIZE_METHOD(<%= options[:component_name] %>,
+                                                   filter_initialize);
+BT_PLUGIN_FILTER_COMPONENT_CLASS_FINALIZE_METHOD(<%= options[:component_name] %>,
+                                                 filter_finalize);
+BT_PLUGIN_FILTER_COMPONENT_CLASS_MESSAGE_ITERATOR_CLASS_INITIALIZE_METHOD(
+    <%= options[:component_name] %>, filter_message_iterator_initialize);
+BT_PLUGIN_FILTER_COMPONENT_CLASS_MESSAGE_ITERATOR_CLASS_FINALIZE_METHOD(
+    <%= options[:component_name] %>, filter_message_iterator_finalize);
+BT_PLUGIN_FILTER_COMPONENT_CLASS_INPUT_PORT_CONNECTED_METHOD(
+    <%= options[:component_name] %>, filter_input_port_connected);

data/template/metababel.h.erb

@@ -0,0 +1,7 @@
+#include <metababel/btx_component.h>
+<% if ['SOURCE', 'FILTER'].include?(options[:component_type]) %>
+#include <metababel/btx_downstream.h>
+<% end %>
+<% if ['FILTER', 'SINK'].include?(options[:component_type]) %>
+#include <metababel/btx_upstream.h>
+<% end %>

data/template/sink.c.erb

@@ -0,0 +1,166 @@
+#include "uthash.h"
+#include <babeltrace2/babeltrace.h>
+#include <metababel/metababel.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+/* Loosely based by
+ * https://babeltrace.org/docs/v2.0/libbabeltrace2/example-simple-sink-cmp-cls.html
+ */
+
+/*
+ * Consume Message
+ */
+
+static bt_component_class_sink_consume_method_status
+sink_consume(bt_self_component_sink *self_component_sink) {
+  bt_component_class_sink_consume_method_status status =
+      BT_COMPONENT_CLASS_SINK_CONSUME_METHOD_STATUS_OK;
+
+  /* Retrieve our private data from the component's user data */
+  /* This containt user data and the message iterator */
+  common_data_t *common_data = bt_self_component_get_data(
+      bt_self_component_sink_as_self_component(self_component_sink));
+
+  /* Consume a batch of messages from the upstream message iterator */
+  bt_message_array_const messages;
+  uint64_t message_count;
+  bt_message_iterator_next_status next_status = bt_message_iterator_next(
+      common_data->message_iterator, &messages, &message_count);
+
+  switch (next_status) {
+  case BT_MESSAGE_ITERATOR_NEXT_STATUS_END:
+    /* End of iteration: put the message iterator's reference */
+    bt_message_iterator_put_ref(common_data->message_iterator);
+    status = BT_COMPONENT_CLASS_SINK_CONSUME_METHOD_STATUS_END;
+    goto end;
+  case BT_MESSAGE_ITERATOR_NEXT_STATUS_AGAIN:
+    status = BT_COMPONENT_CLASS_SINK_CONSUME_METHOD_STATUS_AGAIN;
+    goto end;
+  case BT_MESSAGE_ITERATOR_NEXT_STATUS_MEMORY_ERROR:
+    status = BT_COMPONENT_CLASS_SINK_CONSUME_METHOD_STATUS_MEMORY_ERROR;
+    goto end;
+  case BT_MESSAGE_ITERATOR_NEXT_STATUS_ERROR:
+    status = BT_COMPONENT_CLASS_SINK_CONSUME_METHOD_STATUS_ERROR;
+    goto end;
+  default:
+    break;
+  }
+  /* For each consumed message */
+  for (uint64_t i = 0; i < message_count; i++) {
+    const bt_message *message = messages[i];
+    if (bt_message_get_type(message) != BT_MESSAGE_TYPE_EVENT) {
+      continue;
+    }
+
+    /* Borrow the event message's event and its class */
+    const bt_event *event = bt_message_event_borrow_event_const(message);
+    const bt_event_class *event_class = bt_event_borrow_class_const(event);
+
+    /* Call dispatcher */
+    name_to_dispatcher_t *s = NULL;
+    const char *class_name = bt_event_class_get_name(event_class);
+    HASH_FIND_STR(common_data->name_to_dispatcher, class_name, s);
+    if (s)
+      (*((dispatcher_t(*))(s->dispatcher)))(s->callbacks, common_data, event);
+
+    bt_message_put_ref(message);
+  }
+end:
+  return status;
+}
+
+/*
+ * Initializes the sink component.
+ */
+static bt_component_class_initialize_method_status
+sink_initialize(bt_self_component_sink *self_component_sink,
+                bt_self_component_sink_configuration *configuration,
+                const bt_value *params, void *initialize_method_data) {
+  /* Allocate a private data structure */
+  common_data_t *common_data = calloc(1, sizeof(common_data_t));
+  common_data->params = params;
+  // Read parameters
+  btx_populate_params(common_data);
+
+  bt_value_get_ref(common_data->params);
+
+  /* Register User Callbacks */
+  btx_register_usr_callbacks((void *)common_data);
+
+  /* Call Initialize user callback */
+  btx_call_callbacks_initialize_usr_data(common_data, &common_data->usr_data);
+  /* Call read callbacks */
+  btx_call_callbacks_read_params(common_data, common_data->usr_data,
+                                 common_data->btx_params);
+
+  /* Set the component's user data to our private data structure */
+  bt_self_component_set_data(
+      bt_self_component_sink_as_self_component(self_component_sink),
+      common_data);
+
+  /*
+   * Add an input port named `in` to the sink component.
+   *
+   * This is needed so that this sink component can be connected to a
+   * filter or a source component. With a connected upstream
+   * component, this sink component can create a message iterator
+   * to consume messages.
+   */
+  bt_self_component_sink_add_input_port(self_component_sink, "in", NULL, NULL);
+  return BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_OK;
+}
+
+static void sink_finalize(bt_self_component_sink *self_component_sink) {
+  common_data_t *common_data = bt_self_component_get_data(
+      bt_self_component_sink_as_self_component(self_component_sink));
+
+  /* Finalize User Data */
+  /* Call Finalize user callback */
+  btx_call_callbacks_finalize_usr_data(common_data, common_data->usr_data);
+  // We allocate it, we need to free it
+  free(common_data->btx_params);
+  bt_value_put_ref(common_data->params);
+
+  /* Free the allocated structure */
+  free(common_data);
+}
+
+/*
+ * Called when the trace processing graph containing the sink component
+ * is configured.
+ *
+ * This is where we can create our upstream message iterator.
+ */
+static bt_component_class_sink_graph_is_configured_method_status
+sink_graph_is_configured(bt_self_component_sink *self_component_sink) {
+  /* Retrieve our private data from the component's user data */
+  common_data_t *common_data = bt_self_component_get_data(
+      bt_self_component_sink_as_self_component(self_component_sink));
+
+  /* Borrow our unique port */
+  bt_self_component_port_input *in_port =
+      bt_self_component_sink_borrow_input_port_by_index(self_component_sink, 0);
+
+  /* Create the uptream message iterator */
+  bt_message_iterator_create_from_sink_component(
+      self_component_sink, in_port, &common_data->message_iterator);
+
+  return BT_COMPONENT_CLASS_SINK_GRAPH_IS_CONFIGURED_METHOD_STATUS_OK;
+}
+
+/* Mandatory */
+BT_PLUGIN_MODULE();
+
+BT_PLUGIN(<%= options[:plugin_name] %>);
+// Maybe we should createonly one pluging
+/* Add the output  component class */
+BT_PLUGIN_SINK_COMPONENT_CLASS(<%= options[:component_name] %>, sink_consume);
+
+BT_PLUGIN_SINK_COMPONENT_CLASS_INITIALIZE_METHOD(<%= options[:component_name] %>,
+                                                 sink_initialize);
+BT_PLUGIN_SINK_COMPONENT_CLASS_FINALIZE_METHOD(<%= options[:component_name] %>,
+                                               sink_finalize);
+
+BT_PLUGIN_SINK_COMPONENT_CLASS_GRAPH_IS_CONFIGURED_METHOD(
+    <%= options[:component_name] %>, sink_graph_is_configured);