converter/babeltrace.c

   1 /*
   2  * babeltrace.c
   3  *
   4  * Babeltrace Trace Converter
   5  *
   6  * Copyright 2010-2011 EfficiOS Inc. and Linux Foundation
   7  *
   8  * Author: Mathieu Desnoyers <mathieu.desnoyers@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
  29 #include <babeltrace/babeltrace.h>
  30 #include <babeltrace/plugin/component-factory.h>
  31 #include <babeltrace/plugin/plugin.h>
  32 #include <babeltrace/plugin/component-class.h>
  33 #include <babeltrace/plugin/notification/iterator.h>
  34 #include <babeltrace/ref.h>
  35 #include <babeltrace/values.h>
  36 #include <stdlib.h>
  37 #include <babeltrace/ctf-ir/metadata.h> /* for clocks */
  38 #include <popt.h>
  39 #include <string.h>
  40 #include <stdio.h>
  41 #include "babeltrace-cfg.h"
  42
  43 static
  44 const char *component_type_str(enum bt_component_type type)
  45 {
  46         switch (type) {
  47         case BT_COMPONENT_TYPE_SOURCE:
  48                 return "source";
  49         case BT_COMPONENT_TYPE_SINK:
  50                 return "sink";
  51         case BT_COMPONENT_TYPE_FILTER:
  52                 return "filter";
  53         case BT_COMPONENT_TYPE_UNKNOWN:
  54         default:
  55                 return "unknown";
  56         }
  57 }
  58
  59 static
  60 void print_component_classes_found(struct bt_component_factory *factory)
  61 {
  62         int count, i;
  63
  64         if (!babeltrace_verbose) {
  65                 return;
  66         }
  67
  68         count = bt_component_factory_get_component_class_count(factory);
  69         if (count <= 0) {
  70                 fprintf(stderr, "No component classes found. Please make sure your plug-in search path is set correctly.\n");
  71                 return;
  72         }
  73
  74         printf_verbose("Found %d component classes.\n", count);
  75         for (i = 0; i < count; i++) {
  76                 struct bt_component_class *component_class =
  77                                 bt_component_factory_get_component_class_index(
  78                                 factory, i);
  79                 struct bt_plugin *plugin = bt_component_class_get_plugin(
  80                                 component_class);
  81                 const char *plugin_name = bt_plugin_get_name(plugin);
  82                 const char *component_name = bt_component_class_get_name(
  83                                 component_class);
  84                 const char *path = bt_plugin_get_path(plugin);
  85                 const char *author = bt_plugin_get_author(plugin);
  86                 const char *license = bt_plugin_get_license(plugin);
  87                 const char *plugin_description = bt_plugin_get_description(
  88                                 plugin);
  89                 const char *component_description =
  90                                 bt_component_class_get_description(
  91                                         component_class);
  92                 enum bt_component_type type = bt_component_class_get_type(
  93                                 component_class);
  94
  95                 printf_verbose("[%s - %s (%s)]\n", plugin_name, component_name,
  96                                component_type_str(type));
  97                 printf_verbose("\tpath: %s\n", path ? path : "None");
  98                 printf_verbose("\tauthor: %s\n", author ? author : "Unknown");
  99                 printf_verbose("\tlicense: %s\n", license ? license : "Unknown");
 100                 printf_verbose("\tplugin description: %s\n",
 101                                 plugin_description ? plugin_description : "None");
 102                 printf_verbose("\tcomponent description: %s\n",
 103                                 component_description ? component_description : "None");
 104
 105                 bt_put(plugin);
 106                 bt_put(component_class);
 107         }
 108 }
 109
 110 static
 111 void print_indent(size_t indent)
 112 {
 113         size_t i;
 114
 115         for (i = 0; i < indent; i++) {
 116                 printf(" ");
 117         }
 118 }
 119
 120 static
 121 void print_value(struct bt_value *, size_t, bool);
 122
 123 static
 124 bool print_map_value(const char *key, struct bt_value *object, void *data)
 125 {
 126         size_t indent = (size_t) data;
 127
 128         print_indent(indent);
 129         printf("\"%s\": ", key);
 130         print_value(object, indent, false);
 131
 132         return true;
 133 }
 134
 135 static
 136 void print_value(struct bt_value *value, size_t indent, bool do_indent)
 137 {
 138         bool bool_val;
 139         int64_t int_val;
 140         double dbl_val;
 141         const char *str_val;
 142         int size;
 143         int i;
 144
 145         if (!value) {
 146                 return;
 147         }
 148
 149         if (do_indent) {
 150                 print_indent(indent);
 151         }
 152
 153         switch (bt_value_get_type(value)) {
 154         case BT_VALUE_TYPE_NULL:
 155                 printf("null\n");
 156                 break;
 157         case BT_VALUE_TYPE_BOOL:
 158                 bt_value_bool_get(value, &bool_val);
 159                 printf("%s\n", bool_val ? "true" : "false");
 160                 break;
 161         case BT_VALUE_TYPE_INTEGER:
 162                 bt_value_integer_get(value, &int_val);
 163                 printf("%" PRId64 "\n", int_val);
 164                 break;
 165         case BT_VALUE_TYPE_FLOAT:
 166                 bt_value_float_get(value, &dbl_val);
 167                 printf("%lf\n", dbl_val);
 168                 break;
 169         case BT_VALUE_TYPE_STRING:
 170                 bt_value_string_get(value, &str_val);
 171                 printf("\"%s\"\n", str_val);
 172                 break;
 173         case BT_VALUE_TYPE_ARRAY:
 174                 size = bt_value_array_size(value);
 175                 printf("[\n");
 176
 177                 for (i = 0; i < size; i++) {
 178                         struct bt_value *element =
 179                                         bt_value_array_get(value, i);
 180
 181                         print_value(element, indent + 2, true);
 182                         BT_PUT(element);
 183                 }
 184
 185                 print_indent(indent);
 186                 printf("]\n");
 187                 break;
 188         case BT_VALUE_TYPE_MAP:
 189                 if (bt_value_map_is_empty(value)) {
 190                         printf("{}\n");
 191                         return;
 192                 }
 193
 194                 printf("{\n");
 195                 bt_value_map_foreach(value, print_map_value,
 196                         (void *) (indent + 2));
 197                 print_indent(indent);
 198                 printf("}\n");
 199                 break;
 200         default:
 201                 assert(false);
 202         }
 203 }
 204
 205 static
 206 void print_bt_config_component(struct bt_config_component *bt_config_component)
 207 {
 208         printf("  %s/%s\n", bt_config_component->plugin_name->str,
 209                 bt_config_component->component_name->str);
 210         printf("    params:\n");
 211         print_value(bt_config_component->params, 6, true);
 212 }
 213
 214 static
 215 void print_bt_config_components(GPtrArray *array)
 216 {
 217         size_t i;
 218
 219         for (i = 0; i < array->len; i++) {
 220                 struct bt_config_component *cfg_component =
 221                         bt_config_get_component(array, i);
 222                 print_bt_config_component(cfg_component);
 223                 BT_PUT(cfg_component);
 224         }
 225 }
 226
 227 static
 228 void print_cfg(struct bt_config *cfg)
 229 {
 230         printf("debug:           %d\n", cfg->debug);
 231         printf("verbose:         %d\n", cfg->verbose);
 232         printf("do list:         %d\n", cfg->do_list);
 233         printf("force correlate: %d\n", cfg->force_correlate);
 234         printf("plugin paths:\n");
 235         print_value(cfg->plugin_paths, 2, true);
 236         printf("sources:\n");
 237         print_bt_config_components(cfg->sources);
 238         printf("sinks:\n");
 239         print_bt_config_components(cfg->sinks);
 240 }
 241
 242 int main(int argc, char **argv)
 243 {
 244         int ret;
 245         struct bt_component_factory *component_factory = NULL;
 246         struct bt_component_class *source_class = NULL;
 247         struct bt_component_class *sink_class = NULL;
 248         struct bt_component *source = NULL, *sink = NULL;
 249         struct bt_value *source_params = NULL, *sink_params = NULL;
 250         struct bt_config *cfg;
 251         struct bt_notification_iterator *it = NULL;
 252         enum bt_component_status sink_status;
 253         struct bt_value *first_plugin_path_value = NULL;
 254         const char *first_plugin_path;
 255         struct bt_config_component *cfg_component;
 256
 257         cfg = bt_config_from_args(argc, argv, &ret);
 258         if (cfg) {
 259                 print_cfg(cfg);
 260         } else {
 261                 goto end;
 262         }
 263
 264         babeltrace_verbose = cfg->verbose;
 265         babeltrace_debug = cfg->debug;
 266
 267         /* TODO handle more than 1 source and 1 sink. */
 268         if (cfg->sources->len != 1 || cfg->sinks->len != 1) {
 269                 fprintf(stderr, "Unexpected configuration, aborting.../n");
 270                 ret = -1;
 271                 goto end;
 272         }
 273         cfg_component = bt_config_get_component(cfg->sources, 0);
 274         source_params = bt_get(cfg_component->params);
 275         BT_PUT(cfg_component);
 276         cfg_component = bt_config_get_component(cfg->sinks, 0);
 277         sink_params = bt_get(cfg_component->params);
 278         BT_PUT(cfg_component);
 279
 280         printf_verbose("Verbose mode active.\n");
 281         printf_debug("Debug mode active.\n");
 282         component_factory = bt_component_factory_create();
 283         if (!component_factory) {
 284                 fprintf(stderr, "Failed to create component factory.\n");
 285                 ret = -1;
 286                 goto end;
 287         }
 288
 289         if (cfg->plugin_paths && !bt_value_array_is_empty(cfg->plugin_paths)) {
 290                 first_plugin_path_value = bt_value_array_get(
 291                                 cfg->plugin_paths, 0);
 292                 bt_value_string_get(first_plugin_path_value,
 293                                 &first_plugin_path);
 294                 ret = bt_component_factory_load_recursive(component_factory,
 295                                 first_plugin_path);
 296                 if (ret) {
 297                         fprintf(stderr, "Failed to dynamically load plugins.\n");
 298                         goto end;
 299                 }
 300         }
 301
 302         ret = bt_component_factory_load_static(component_factory);
 303         if (ret) {
 304                 fprintf(stderr, "Failed to load static plugins.\n");
 305                 goto end;
 306         }
 307
 308         print_component_classes_found(component_factory);
 309         source_class = bt_component_factory_get_component_class(
 310                         component_factory, "ctf", BT_COMPONENT_TYPE_SOURCE,
 311                         "fs");
 312         if (!source_class) {
 313                 fprintf(stderr, "Could not find ctf-fs source component class. Aborting...\n");
 314                 ret = -1;
 315                 goto end;
 316         }
 317
 318         sink_class = bt_component_factory_get_component_class(component_factory,
 319                         NULL, BT_COMPONENT_TYPE_SINK, "text");
 320         if (!sink_class) {
 321                 fprintf(stderr, "Could not find text output component class. Aborting...\n");
 322                 ret = -1;
 323                 goto end;
 324         }
 325
 326         source = bt_component_create(source_class, "ctf-fs", source_params);
 327         if (!source) {
 328                 fprintf(stderr, "Failed to instantiate ctf-fs source component. Aborting...\n");
 329                 ret = -1;
 330                 goto end;
 331         }
 332
 333         sink = bt_component_create(sink_class, "text", sink_params);
 334         if (!sink) {
 335                 fprintf(stderr, "Failed to instanciate text output component. Aborting...\n");
 336                 ret = -1;
 337                 goto end;
 338         }
 339
 340         it = bt_component_source_create_iterator(source);
 341         if (!it) {
 342                 fprintf(stderr, "Failed to instantiate source iterator. Aborting...\n");
 343                 ret = -1;
 344                 goto end;
 345         }
 346
 347         sink_status = bt_component_sink_add_iterator(sink, it);
 348         if (sink_status != BT_COMPONENT_STATUS_OK) {
 349                 ret = -1;
 350                 goto end;
 351         }
 352
 353         while (true) {
 354                 sink_status = bt_component_sink_consume(sink);
 355                 switch (sink_status) {
 356                 case BT_COMPONENT_STATUS_AGAIN:
 357                         /* Wait for an arbitraty 500 ms. */
 358                         usleep(500000);
 359                         break;
 360                 case BT_COMPONENT_STATUS_OK:
 361                         break;
 362                 case BT_COMPONENT_STATUS_END:
 363                         goto end;
 364                 default:
 365                         fprintf(stderr, "Sink component returned an error, aborting...\n");
 366                         ret = -1;
 367                         goto end;
 368                 }
 369         }
 370 end:
 371         BT_PUT(component_factory);
 372         BT_PUT(sink_class);
 373         BT_PUT(source_class);
 374         BT_PUT(source);
 375         BT_PUT(sink);
 376         BT_PUT(source_params);
 377         BT_PUT(sink_params);
 378         BT_PUT(it);
 379         BT_PUT(cfg);
 380         BT_PUT(first_plugin_path_value);
 381         return ret ? 1 : 0;
 382 }