X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=converter%2Fbabeltrace.c;h=88d8423ec043b431444f6df7795744e01e69ca29;hb=5e86a07184ae8412f8c76b0392930e7f3be65454;hp=e3436afa28a4272e180db25069363dd50c80e8b5;hpb=fec2a9f220bdae0ce64716538c111348302f2696;p=babeltrace.git diff --git a/converter/babeltrace.c b/converter/babeltrace.c index e3436afa..88d8423e 100644 --- a/converter/babeltrace.c +++ b/converter/babeltrace.c @@ -38,94 +38,7 @@ #include #include #include - - -static char *opt_plugin_path; -static char *opt_input_path; - -enum { - OPT_NONE = 0, - OPT_PLUGIN_PATH, - OPT_INPUT_PATH, - OPT_VERBOSE, - OPT_DEBUG, - OPT_HELP, -}; - -/* - * We are _not_ using POPT_ARG_STRING's ability to store directly into - * variables, because we want to cast the return to non-const, which is - * not possible without using poptGetOptArg explicitly. This helps us - * controlling memory allocation correctly without making assumptions - * about undocumented behaviors. poptGetOptArg is documented as - * requiring the returned const char * to be freed by the caller. - */ -static struct poptOption long_options[] = { - /* longName, shortName, argInfo, argPtr, value, descrip, argDesc */ - { "plugin-path", 0, POPT_ARG_STRING, NULL, OPT_PLUGIN_PATH, NULL, NULL }, - { "input-path", 0, POPT_ARG_STRING, NULL, OPT_INPUT_PATH, NULL, NULL }, - { "verbose", 'v', POPT_ARG_NONE, NULL, OPT_VERBOSE, NULL, NULL }, - { "debug", 'd', POPT_ARG_NONE, NULL, OPT_DEBUG, NULL, NULL }, - { NULL, 0, 0, NULL, 0, NULL, NULL }, -}; - -/* - * Return 0 if caller should continue, < 0 if caller should return - * error, > 0 if caller should exit without reporting error. - */ -static int parse_options(int argc, char **argv) -{ - poptContext pc; - int opt, ret = 0; - - if (argc == 1) { - return 1; /* exit cleanly */ - } - - pc = poptGetContext(NULL, argc, (const char **) argv, long_options, 0); - poptReadDefaultConfig(pc, 0); - - /* set default */ - opt_context_field_names = 1; - opt_payload_field_names = 1; - - while ((opt = poptGetNextOpt(pc)) != -1) { - switch (opt) { - case OPT_HELP: - ret = 1; /* exit cleanly */ - goto end; - case OPT_PLUGIN_PATH: - opt_plugin_path = (char *) poptGetOptArg(pc); - if (!opt_plugin_path) { - ret = -EINVAL; - goto end; - } - break; - case OPT_VERBOSE: - babeltrace_verbose = 1; - break; - case OPT_DEBUG: - babeltrace_debug = 1; - break; - case OPT_INPUT_PATH: - opt_input_path = (char *) poptGetOptArg(pc); - if (!opt_input_path) { - ret = -EINVAL; - goto end; - } - break; - default: - ret = -EINVAL; - goto end; - } - } - -end: - if (pc) { - poptFreeContext(pc); - } - return ret; -} +#include "babeltrace-cfg.h" static const char *component_type_str(enum bt_component_type type) @@ -144,7 +57,7 @@ const char *component_type_str(enum bt_component_type type) } static -void print_found_component_classes(struct bt_component_factory *factory) +void print_component_classes_found(struct bt_component_factory *factory) { int count, i; @@ -154,7 +67,7 @@ void print_found_component_classes(struct bt_component_factory *factory) count = bt_component_factory_get_component_class_count(factory); if (count <= 0) { - fprintf(stderr, "No component classes found. Please make sure your plug-in search path is set correctly."); + fprintf(stderr, "No component classes found. Please make sure your plug-in search path is set correctly.\n"); return; } @@ -194,49 +107,184 @@ void print_found_component_classes(struct bt_component_factory *factory) } } +static +void print_indent(size_t indent) +{ + size_t i; + + for (i = 0; i < indent; i++) { + printf(" "); + } +} + +static +void print_value(struct bt_value *, size_t, bool); + +static +bool print_map_value(const char *key, struct bt_value *object, void *data) +{ + size_t indent = (size_t) data; + + print_indent(indent); + printf("\"%s\": ", key); + print_value(object, indent, false); + + return true; +} + +static +void print_value(struct bt_value *value, size_t indent, bool do_indent) +{ + bool bool_val; + int64_t int_val; + double dbl_val; + const char *str_val; + int size; + int i; + + if (!value) { + return; + } + + if (do_indent) { + print_indent(indent); + } + + switch (bt_value_get_type(value)) { + case BT_VALUE_TYPE_NULL: + printf("null\n"); + break; + case BT_VALUE_TYPE_BOOL: + bt_value_bool_get(value, &bool_val); + printf("%s\n", bool_val ? "true" : "false"); + break; + case BT_VALUE_TYPE_INTEGER: + bt_value_integer_get(value, &int_val); + printf("%" PRId64 "\n", int_val); + break; + case BT_VALUE_TYPE_FLOAT: + bt_value_float_get(value, &dbl_val); + printf("%lf\n", dbl_val); + break; + case BT_VALUE_TYPE_STRING: + bt_value_string_get(value, &str_val); + printf("\"%s\"\n", str_val); + break; + case BT_VALUE_TYPE_ARRAY: + size = bt_value_array_size(value); + printf("[\n"); + + for (i = 0; i < size; i++) { + struct bt_value *element = + bt_value_array_get(value, i); + + print_value(element, indent + 2, true); + BT_PUT(element); + } + + print_indent(indent); + printf("]\n"); + break; + case BT_VALUE_TYPE_MAP: + if (bt_value_map_is_empty(value)) { + printf("{}\n"); + return; + } + + printf("{\n"); + bt_value_map_foreach(value, print_map_value, + (void *) (indent + 2)); + print_indent(indent); + printf("}\n"); + break; + default: + assert(false); + } +} + +static +void print_bt_config_component(struct bt_config_component *bt_config_component) +{ + printf(" %s/%s\n", bt_config_component->plugin_name->str, + bt_config_component->component_name->str); + printf(" params:\n"); + print_value(bt_config_component->params, 6, true); +} + +static +void print_bt_config_components(GPtrArray *array) +{ + size_t i; + + for (i = 0; i < array->len; i++) { + struct bt_config_component *cfg_component = + bt_config_get_component(array, i); + print_bt_config_component(cfg_component); + BT_PUT(cfg_component); + } +} + +static +void print_cfg(struct bt_config *cfg) +{ + printf("debug: %d\n", cfg->debug); + printf("verbose: %d\n", cfg->verbose); + printf("do list: %d\n", cfg->do_list); + printf("force correlate: %d\n", cfg->force_correlate); + printf("plugin paths:\n"); + print_value(cfg->plugin_paths, 2, true); + printf("sources:\n"); + print_bt_config_components(cfg->sources); + printf("sinks:\n"); + print_bt_config_components(cfg->sinks); +} + int main(int argc, char **argv) { int ret; - enum bt_value_status value_status; struct bt_component_factory *component_factory = NULL; - struct bt_component_class *source_class = NULL, *sink_class = NULL; + struct bt_component_class *source_class = NULL; + struct bt_component_class *sink_class = NULL; struct bt_component *source = NULL, *sink = NULL; struct bt_value *source_params = NULL, *sink_params = NULL; + struct bt_config *cfg; struct bt_notification_iterator *it = NULL; enum bt_component_status sink_status; - - ret = parse_options(argc, argv); - if (ret < 0) { - fprintf(stderr, "Error parsing options.\n\n"); - exit(EXIT_FAILURE); - } else if (ret > 0) { - exit(EXIT_SUCCESS); - } - - source_params = bt_value_map_create(); - if (!source_params) { - fprintf(stderr, "Failed to create source parameters map, aborting...\n"); - ret = -1; + struct bt_value *first_plugin_path_value = NULL; + const char *first_plugin_path; + struct bt_config_component *cfg_component; + + cfg = bt_config_from_args(argc, argv, &ret); + if (cfg) { + print_cfg(cfg); + } else { goto end; } - value_status = bt_value_map_insert_string(source_params, "path", - opt_input_path); - if (value_status != BT_VALUE_STATUS_OK) { + babeltrace_verbose = cfg->verbose; + babeltrace_debug = cfg->debug; + + /* TODO handle more than 1 source and 1 sink. */ + if (cfg->sources->len != 1 || cfg->sinks->len != 1) { + fprintf(stderr, "Unexpected configuration, aborting.../n"); ret = -1; goto end; } + cfg_component = bt_config_get_component(cfg->sources, 0); + source_params = bt_get(cfg_component->params); + BT_PUT(cfg_component); + cfg_component = bt_config_get_component(cfg->sinks, 0); + sink_params = bt_get(cfg_component->params); + BT_PUT(cfg_component); printf_verbose("Verbose mode active.\n"); printf_debug("Debug mode active.\n"); - if (!opt_plugin_path) { + if (bt_value_array_is_empty(cfg->plugin_paths)) { fprintf(stderr, "No plugin path specified, aborting...\n"); ret = -1; goto end; } - printf_verbose("Looking-up plugins at %s\n", - opt_plugin_path ? opt_plugin_path : "Invalid"); component_factory = bt_component_factory_create(); if (!component_factory) { fprintf(stderr, "Failed to create component factory.\n"); @@ -244,14 +292,23 @@ int main(int argc, char **argv) goto end; } - ret = bt_component_factory_load_recursive(component_factory, opt_plugin_path); + first_plugin_path_value = bt_value_array_get(cfg->plugin_paths, 0); + bt_value_string_get(first_plugin_path_value, &first_plugin_path); + + ret = bt_component_factory_load_recursive(component_factory, + first_plugin_path); if (ret) { fprintf(stderr, "Failed to load plugins.\n"); goto end; } - print_found_component_classes(component_factory); + ret = bt_component_factory_load_static(component_factory); + if (ret) { + fprintf(stderr, "Failed to load static plugins.\n"); + goto end; + } + print_component_classes_found(component_factory); source_class = bt_component_factory_get_component_class( component_factory, "ctf", BT_COMPONENT_TYPE_SOURCE, "fs"); @@ -262,23 +319,23 @@ int main(int argc, char **argv) } sink_class = bt_component_factory_get_component_class(component_factory, - "text", BT_COMPONENT_TYPE_SINK, "text"); + NULL, BT_COMPONENT_TYPE_SINK, "text"); if (!sink_class) { - fprintf(stderr, "Could not find text sink component class. Aborting...\n"); + fprintf(stderr, "Could not find text output component class. Aborting...\n"); ret = -1; goto end; } source = bt_component_create(source_class, "ctf-fs", source_params); if (!source) { - fprintf(stderr, "Failed to instantiate source component. Aborting...\n"); - ret = -1; - goto end; - } + fprintf(stderr, "Failed to instantiate ctf-fs source component. Aborting...\n"); + ret = -1; + goto end; + } - sink = bt_component_create(sink_class, "bt_text_output", sink_params); + sink = bt_component_create(sink_class, "text", sink_params); if (!sink) { - fprintf(stderr, "Failed to instantiate output component. Aborting...\n"); + fprintf(stderr, "Failed to instanciate text output component. Aborting...\n"); ret = -1; goto end; } @@ -286,9 +343,9 @@ int main(int argc, char **argv) it = bt_component_source_create_iterator(source); if (!it) { fprintf(stderr, "Failed to instantiate source iterator. Aborting...\n"); - ret = -1; - goto end; - } + ret = -1; + goto end; + } sink_status = bt_component_sink_add_iterator(sink, it); if (sink_status != BT_COMPONENT_STATUS_OK) { @@ -298,7 +355,6 @@ int main(int argc, char **argv) while (true) { sink_status = bt_component_sink_consume(sink); - switch (sink_status) { case BT_COMPONENT_STATUS_AGAIN: /* Wait for an arbitraty 500 ms. */ @@ -314,7 +370,6 @@ int main(int argc, char **argv) goto end; } } - /* teardown and exit */ end: BT_PUT(component_factory); BT_PUT(sink_class); @@ -324,5 +379,7 @@ end: BT_PUT(source_params); BT_PUT(sink_params); BT_PUT(it); + BT_PUT(cfg); + BT_PUT(first_plugin_path_value); return ret ? 1 : 0; }