From: Philippe Proulx Date: Sat, 20 Jul 2019 17:48:17 +0000 (-0400) Subject: lib: add bt_plugin_find_all() X-Git-Url: http://git.efficios.com/?p=babeltrace.git;a=commitdiff_plain;h=577fa92f184fd2d75fb0697e879ab563de117c2e lib: add bt_plugin_find_all() This patch adds the public bt_plugin_find_all() function to find all the plugins found in directories with the standard search order. The motivation of this patch is to use bt_plugin_find_all() in the CLI instead of duplicating the search algorithm (see load_all_plugins() in `babeltrace2-plugins.c`). bt_plugin_find_all() returns a plugin set. It takes four boolean parameters to indicate whether or not it must search in: * The directories specified by the standard environment variable (`BABELTRACE_PLUGIN_PATH`). * The system's plugin directory. * The user's plugin directory. * The built-in/static plugins. All the plugins within a plugin set have unique names. When a plugin is found in bt_plugin_find_all() and the output plugin set already has a plugin with this name, it is discarded. bt_plugin_find() is changed to use bt_plugin_find_all(). It also gains the four boolean parameters to exclude a specific step of the search algorithm. In the `bt2` Python package: * bt2.find_plugins() is renamed to bt2.find_plugins_in_path(). * bt2.find_plugins() wraps bt_plugin_find_all(). * Optional boolean parameters are added to bt2.find_plugin() to fully wrap bt_plugin_find(). In `tests/lib/plugin.c`, `BT_FALSE` is passed to all the directory exclusion parameters except for `find_in_std_env_var` to isolate the search within those specific directories, without the system's or user's plugin directory having an influence on the test. Signed-off-by: Philippe Proulx Change-Id: Icad1387d64d15a639da107ab1ba30e5a53136ced Reviewed-on: https://review.lttng.org/c/babeltrace/+/1729 Tested-by: jenkins --- diff --git a/include/babeltrace2/plugin/plugin-const.h b/include/babeltrace2/plugin/plugin-const.h index 11a6a01f..65b66def 100644 --- a/include/babeltrace2/plugin/plugin-const.h +++ b/include/babeltrace2/plugin/plugin-const.h @@ -45,8 +45,22 @@ typedef enum bt_plugin_find_status { } bt_plugin_find_status; extern bt_plugin_find_status bt_plugin_find(const char *plugin_name, + bt_bool find_in_std_env_var, bt_bool find_in_user_dir, + bt_bool find_in_sys_dir, bt_bool find_in_static, bt_bool fail_on_load_error, const bt_plugin **plugin); +typedef enum bt_plugin_find_all_status { + BT_PLUGIN_FIND_ALL_STATUS_OK = __BT_FUNC_STATUS_OK, + BT_PLUGIN_FIND_ALL_STATUS_NOT_FOUND = __BT_FUNC_STATUS_NOT_FOUND, + BT_PLUGIN_FIND_ALL_STATUS_ERROR = __BT_FUNC_STATUS_ERROR, + BT_PLUGIN_FIND_ALL_STATUS_MEMORY_ERROR = __BT_FUNC_STATUS_MEMORY_ERROR, +} bt_plugin_find_all_status; + +bt_plugin_find_all_status bt_plugin_find_all(bt_bool find_in_std_env_var, + bt_bool find_in_user_dir, bt_bool find_in_sys_dir, + bt_bool find_in_static, bt_bool fail_on_load_error, + const bt_plugin_set **plugin_set); + typedef enum bt_plugin_find_all_from_file_status { BT_PLUGIN_FIND_ALL_FROM_FILE_STATUS_OK = __BT_FUNC_STATUS_OK, BT_PLUGIN_FIND_ALL_FROM_FILE_STATUS_NOT_FOUND = __BT_FUNC_STATUS_NOT_FOUND, diff --git a/src/bindings/python/bt2/bt2/native_bt_plugin.i b/src/bindings/python/bt2/bt2/native_bt_plugin.i index 4cdf9a41..a0c2b3f1 100644 --- a/src/bindings/python/bt2/bt2/native_bt_plugin.i +++ b/src/bindings/python/bt2/bt2/native_bt_plugin.i @@ -74,8 +74,15 @@ bt_property_availability bt_bt2_plugin_get_version( unsigned int *minor, unsigned int *patch, const char **extra); bt_plugin_find_status bt_bt2_plugin_find(const char *plugin_name, + bt_bool find_in_std_env_var, bt_bool find_in_user_dir, + bt_bool find_in_sys_dir, bt_bool find_in_static, bt_bool fail_on_load_error, const bt_plugin **plugin); +bt_plugin_find_all_status bt_bt2_plugin_find_all(bt_bool find_in_std_env_var, + bt_bool find_in_user_dir, bt_bool find_in_sys_dir, + bt_bool find_in_static, bt_bool fail_on_load_error, + const bt_plugin_set **plugin_set); + bt_plugin_find_all_from_file_status bt_bt2_plugin_find_all_from_file( const char *path, bt_bool fail_on_load_error, const bt_plugin_set **plugin_set); @@ -109,12 +116,15 @@ bt_property_availability bt_bt2_plugin_get_version( } bt_plugin_find_status bt_bt2_plugin_find(const char *plugin_name, + bt_bool find_in_std_env_var, bt_bool find_in_user_dir, + bt_bool find_in_sys_dir, bt_bool find_in_static, bt_bool fail_on_load_error, const bt_plugin **plugin) { bt_plugin_find_status status; - status = bt_plugin_find(plugin_name, fail_on_load_error, - plugin); + status = bt_plugin_find(plugin_name, find_in_std_env_var, + find_in_user_dir, find_in_sys_dir, find_in_static, + fail_on_load_error, plugin); if (status != __BT_FUNC_STATUS_OK) { *plugin = NULL; } @@ -122,6 +132,23 @@ bt_plugin_find_status bt_bt2_plugin_find(const char *plugin_name, return status; } +bt_plugin_find_all_status bt_bt2_plugin_find_all(bt_bool find_in_std_env_var, + bt_bool find_in_user_dir, bt_bool find_in_sys_dir, + bt_bool find_in_static, bt_bool fail_on_load_error, + const bt_plugin_set **plugin_set) +{ + bt_plugin_find_all_status status; + + status = bt_plugin_find_all(find_in_std_env_var, + find_in_user_dir, find_in_sys_dir, find_in_static, + fail_on_load_error, plugin_set); + if (status != __BT_FUNC_STATUS_OK) { + *plugin_set = NULL; + } + + return status; +} + bt_plugin_find_all_from_file_status bt_bt2_plugin_find_all_from_file( const char *path, bt_bool fail_on_load_error, const bt_plugin_set **plugin_set) diff --git a/src/bindings/python/bt2/bt2/plugin.py b/src/bindings/python/bt2/bt2/plugin.py index 5198bdf3..597f38f2 100644 --- a/src/bindings/python/bt2/bt2/plugin.py +++ b/src/bindings/python/bt2/bt2/plugin.py @@ -27,7 +27,7 @@ import os.path import bt2 -def find_plugins(path, recurse=True, fail_on_load_error=False): +def find_plugins_in_path(path, recurse=True, fail_on_load_error=False): utils._check_str(path) utils._check_bool(recurse) utils._check_bool(fail_on_load_error) @@ -52,10 +52,54 @@ def find_plugins(path, recurse=True, fail_on_load_error=False): return _PluginSet._create_from_ptr(plugin_set_ptr) -def find_plugin(name, fail_on_load_error=False): +def find_plugins( + find_in_std_env_var=True, + find_in_user_dir=True, + find_in_sys_dir=True, + find_in_static=True, + fail_on_load_error=False, +): + utils._check_bool(find_in_std_env_var) + utils._check_bool(find_in_user_dir) + utils._check_bool(find_in_sys_dir) + utils._check_bool(find_in_static) + utils._check_bool(fail_on_load_error) + plugin_set_ptr = None + + status, plugin_set_ptr = native_bt.bt2_plugin_find_all( + int(find_in_std_env_var), + int(find_in_user_dir), + int(find_in_sys_dir), + int(find_in_static), + int(fail_on_load_error), + ) + + if status == native_bt.__BT_FUNC_STATUS_NOT_FOUND: + return + + utils._handle_func_status(status, 'failed to find plugins') + assert plugin_set_ptr is not None + return _PluginSet._create_from_ptr(plugin_set_ptr) + + +def find_plugin( + name, + find_in_std_env_var=True, + find_in_user_dir=True, + find_in_sys_dir=True, + find_in_static=True, + fail_on_load_error=False, +): utils._check_str(name) utils._check_bool(fail_on_load_error) - status, ptr = native_bt.bt2_plugin_find(name, int(fail_on_load_error)) + status, ptr = native_bt.bt2_plugin_find( + name, + int(find_in_std_env_var), + int(find_in_user_dir), + int(find_in_sys_dir), + int(find_in_static), + int(fail_on_load_error), + ) if status == native_bt.__BT_FUNC_STATUS_NOT_FOUND: return diff --git a/src/lib/plugin/plugin.c b/src/lib/plugin/plugin.c index 5537cb0d..33ba6c9d 100644 --- a/src/lib/plugin/plugin.c +++ b/src/lib/plugin/plugin.c @@ -258,28 +258,30 @@ end: return status; } -static void destroy_gstring(void *data) +static +void destroy_gstring(void *data) { g_string_free(data, TRUE); } -enum bt_plugin_find_status bt_plugin_find(const char *plugin_name, - bt_bool fail_on_load_error, const struct bt_plugin **plugin_out) +enum bt_plugin_find_all_status bt_plugin_find_all(bt_bool find_in_std_env_var, + bt_bool find_in_user_dir, bt_bool find_in_sys_dir, + bt_bool find_in_static, bt_bool fail_on_load_error, + const struct bt_plugin_set **plugin_set_out) { - const char *system_plugin_dir; char *home_plugin_dir = NULL; - const char *envvar; - const struct bt_plugin *plugin = NULL; const struct bt_plugin_set *plugin_set = NULL; GPtrArray *dirs = NULL; int ret; int status = BT_FUNC_STATUS_OK; - size_t i, j; + uint64_t dir_i, plugin_i; - BT_ASSERT_PRE_NON_NULL(plugin_name, "Name"); - BT_ASSERT_PRE_NON_NULL(plugin_out, "Plugin (output)"); - BT_LOGI("Finding named plugin in standard directories and built-in plugins: " - "name=\"%s\"", plugin_name); + BT_ASSERT_PRE_NON_NULL(plugin_set_out, "Plugin set (output)"); + BT_LOGI("Finding all plugins in standard directories and built-in plugins: " + "find-in-std-env-var=%d, find-in-user-dir=%d, " + "find-in-sys-dir=%d, find-in-static=%d", + find_in_std_env_var, find_in_user_dir, find_in_sys_dir, + find_in_static); dirs = g_ptr_array_new_with_free_func((GDestroyNotify) destroy_gstring); if (!dirs) { BT_LIB_LOGE_APPEND_CAUSE("Failed to allocate a GPtrArray."); @@ -287,60 +289,77 @@ enum bt_plugin_find_status bt_plugin_find(const char *plugin_name, goto end; } + *plugin_set_out = bt_plugin_set_create(); + if (!*plugin_set_out) { + BT_LIB_LOGE_APPEND_CAUSE("Cannot create empty plugin set."); + status = BT_FUNC_STATUS_MEMORY_ERROR; + goto end; + } + /* * Search order is: * - * 1. BABELTRACE_PLUGIN_PATH environment variable + * 1. `BABELTRACE_PLUGIN_PATH` environment variable * (colon-separated list of directories) - * 2. ~/.local/lib/babeltrace2/plugins + * 2. `~/.local/lib/babeltrace2/plugins` * 3. Default system directory for Babeltrace plugins, usually - * /usr/lib/babeltrace2/plugins or - * /usr/local/lib/babeltrace2/plugins if installed - * locally + * `/usr/lib/babeltrace2/plugins` or + * `/usr/local/lib/babeltrace2/plugins` if installed locally * 4. Built-in plugins (static) * * Directories are searched non-recursively. */ - envvar = getenv("BABELTRACE_PLUGIN_PATH"); - if (envvar) { - ret = bt_common_append_plugin_path_dirs(envvar, dirs); - if (ret) { - BT_LIB_LOGE_APPEND_CAUSE( - "Failed to append plugin path to array of directories."); - status = BT_FUNC_STATUS_MEMORY_ERROR; - goto end; + if (find_in_std_env_var) { + const char *envvar = getenv("BABELTRACE_PLUGIN_PATH"); + + if (envvar) { + ret = bt_common_append_plugin_path_dirs(envvar, dirs); + if (ret) { + BT_LIB_LOGE_APPEND_CAUSE( + "Failed to append plugin path to array of directories."); + status = BT_FUNC_STATUS_MEMORY_ERROR; + goto end; + } } } - home_plugin_dir = bt_common_get_home_plugin_path(BT_LOG_OUTPUT_LEVEL); - if (home_plugin_dir) { - GString *home_plugin_dir_str = g_string_new(home_plugin_dir); + if (find_in_user_dir) { + home_plugin_dir = bt_common_get_home_plugin_path( + BT_LOG_OUTPUT_LEVEL); + if (home_plugin_dir) { + GString *home_plugin_dir_str = g_string_new( + home_plugin_dir); - if (!home_plugin_dir_str) { - BT_LIB_LOGE_APPEND_CAUSE("Failed to allocate a GString."); - status = BT_FUNC_STATUS_MEMORY_ERROR; - goto end; - } + if (!home_plugin_dir_str) { + BT_LIB_LOGE_APPEND_CAUSE("Failed to allocate a GString."); + status = BT_FUNC_STATUS_MEMORY_ERROR; + goto end; + } - g_ptr_array_add(dirs, home_plugin_dir_str); + g_ptr_array_add(dirs, home_plugin_dir_str); + } } - system_plugin_dir = bt_common_get_system_plugin_path(); - if (system_plugin_dir) { - GString *system_plugin_dir_str = - g_string_new(system_plugin_dir); + if (find_in_sys_dir) { + const char *system_plugin_dir = + bt_common_get_system_plugin_path(); - if (!system_plugin_dir_str) { - BT_LIB_LOGE_APPEND_CAUSE("Failed to allocate a GString."); - status = BT_FUNC_STATUS_MEMORY_ERROR; - goto end; - } + if (system_plugin_dir) { + GString *system_plugin_dir_str = + g_string_new(system_plugin_dir); + + if (!system_plugin_dir_str) { + BT_LIB_LOGE_APPEND_CAUSE("Failed to allocate a GString."); + status = BT_FUNC_STATUS_MEMORY_ERROR; + goto end; + } - g_ptr_array_add(dirs, system_plugin_dir_str); + g_ptr_array_add(dirs, system_plugin_dir_str); + } } - for (i = 0; i < dirs->len; i++) { - GString *dir = g_ptr_array_index(dirs, i); + for (dir_i = 0; dir_i < dirs->len; dir_i++) { + GString *dir = dirs->pdata[dir_i]; BT_OBJECT_PUT_REF_AND_RESET(plugin_set); @@ -369,49 +388,98 @@ enum bt_plugin_find_status bt_plugin_find(const char *plugin_name, BT_ASSERT(status == BT_FUNC_STATUS_OK); BT_ASSERT(plugin_set); + BT_LOGI("Found plugins in directory: path=\"%s\", count=%u", + dir->str, plugin_set->plugins->len); - for (j = 0; j < plugin_set->plugins->len; j++) { - const struct bt_plugin *candidate_plugin = - g_ptr_array_index(plugin_set->plugins, j); + for (plugin_i = 0; plugin_i < plugin_set->plugins->len; + plugin_i++) { + bt_plugin_set_add_plugin((void *) *plugin_set_out, + plugin_set->plugins->pdata[plugin_i]); + } + } - if (strcmp(bt_plugin_get_name(candidate_plugin), - plugin_name) == 0) { - BT_LOGI("Plugin found in directory: name=\"%s\", path=\"%s\"", - plugin_name, dir->str); - *plugin_out = candidate_plugin; - bt_object_get_no_null_check(*plugin_out); - goto end; - } + if (find_in_static) { + BT_OBJECT_PUT_REF_AND_RESET(plugin_set); + status = bt_plugin_find_all_from_static(fail_on_load_error, + &plugin_set); + if (status < 0) { + BT_ASSERT(!plugin_set); + goto end; + } else if (status == BT_FUNC_STATUS_NOT_FOUND) { + BT_ASSERT(!plugin_set); + BT_LOGI_STR("No plugins found in built-in plugins."); + goto end; + } + + BT_ASSERT(status == BT_FUNC_STATUS_OK); + BT_ASSERT(plugin_set); + BT_LOGI("Found built-in plugins: count=%u", + plugin_set->plugins->len); + + for (plugin_i = 0; plugin_i < plugin_set->plugins->len; + plugin_i++) { + bt_plugin_set_add_plugin((void *) *plugin_set_out, + plugin_set->plugins->pdata[plugin_i]); } + } - BT_LOGI("Plugin not found in directory: name=\"%s\", path=\"%s\"", - plugin_name, dir->str); +end: + free(home_plugin_dir); + bt_object_put_ref(plugin_set); + + if (dirs) { + g_ptr_array_free(dirs, TRUE); } - BT_OBJECT_PUT_REF_AND_RESET(plugin_set); - status = bt_plugin_find_all_from_static(fail_on_load_error, - &plugin_set); if (status < 0) { - BT_ASSERT(!plugin_set); - goto end; - } else if (status == BT_FUNC_STATUS_NOT_FOUND) { - BT_ASSERT(!plugin_set); - BT_LOGI_STR("No plugins found in built-in plugins."); + BT_OBJECT_PUT_REF_AND_RESET(*plugin_set_out); + } else { + BT_ASSERT(*plugin_set_out); + + if ((*plugin_set_out)->plugins->len > 0) { + BT_LOGI("Found plugins in standard directories and built-in plugins: " + "count=%u", (*plugin_set_out)->plugins->len); + status = BT_FUNC_STATUS_OK; + } else { + BT_LOGI_STR("No plugins found in standard directories and built-in plugins."); + status = BT_FUNC_STATUS_NOT_FOUND; + BT_OBJECT_PUT_REF_AND_RESET(*plugin_set_out); + } + } + + return status; +} + +enum bt_plugin_find_status bt_plugin_find(const char *plugin_name, + bt_bool find_in_std_env_var, bt_bool find_in_user_dir, + bt_bool find_in_sys_dir, bt_bool find_in_static, + bt_bool fail_on_load_error, const struct bt_plugin **plugin_out) +{ + enum bt_plugin_find_status status; + const struct bt_plugin_set *plugin_set = NULL; + uint64_t i; + + BT_ASSERT_PRE_NON_NULL(plugin_name, "Name"); + BT_ASSERT_PRE_NON_NULL(plugin_out, "Plugin (output)"); + BT_LOGI("Finding named plugin in standard directories and built-in plugins: " + "name=\"%s\", find-in-std-env-var=%d, find-in-user-dir=%d, " + "find-in-sys-dir=%d, find-in-static=%d", + plugin_name, find_in_std_env_var, find_in_user_dir, + find_in_sys_dir, find_in_static); + status = bt_plugin_find_all(find_in_std_env_var, find_in_user_dir, + find_in_sys_dir, find_in_static, fail_on_load_error, + &plugin_set); + if (status != BT_FUNC_STATUS_OK) { goto end; } - BT_ASSERT(status == BT_FUNC_STATUS_OK); BT_ASSERT(plugin_set); - for (j = 0; j < plugin_set->plugins->len; j++) { - const struct bt_plugin *candidate_plugin = - g_ptr_array_index(plugin_set->plugins, j); + for (i = 0; i < plugin_set->plugins->len; i++) { + const struct bt_plugin *plugin = plugin_set->plugins->pdata[i]; - if (strcmp(bt_plugin_get_name(candidate_plugin), - plugin_name) == 0) { - BT_LOGI("Plugin found in built-in plugins: " - "name=\"%s\"", plugin_name); - *plugin_out = candidate_plugin; + if (strcmp(plugin->info.name->str, plugin_name) == 0) { + *plugin_out = plugin; bt_object_get_no_null_check(*plugin_out); goto end; } @@ -420,17 +488,11 @@ enum bt_plugin_find_status bt_plugin_find(const char *plugin_name, status = BT_FUNC_STATUS_NOT_FOUND; end: - free(home_plugin_dir); - bt_object_put_ref(plugin_set); - - if (dirs) { - g_ptr_array_free(dirs, TRUE); - } - if (status == BT_FUNC_STATUS_OK) { + BT_ASSERT(*plugin_out); BT_LIB_LOGI("Found plugin in standard directories and built-in plugins: " - "%!+l", plugin); - } else if (status == BT_FUNC_STATUS_NOT_FOUND) { + "%!+l", *plugin_out); + } else if (status == BT_FUNC_STATUS_NOT_FOUND) { BT_LOGI("No plugin found in standard directories and built-in plugins: " "name=\"%s\"", plugin_name); } diff --git a/src/lib/plugin/plugin.h b/src/lib/plugin/plugin.h index 61698722..ba4f4551 100644 --- a/src/lib/plugin/plugin.h +++ b/src/lib/plugin/plugin.h @@ -416,17 +416,49 @@ end: return plugin_set; } +static inline +bool bt_plugin_set_contains_plugin(struct bt_plugin_set *plugin_set, + const char *name) +{ + uint64_t i; + bool contains = false; + + BT_ASSERT(plugin_set); + BT_ASSERT(name); + + for (i = 0; i < plugin_set->plugins->len; i++) { + const struct bt_plugin *plugin = plugin_set->plugins->pdata[i]; + + if (strcmp(plugin->info.name->str, name) == 0) { + contains = true; + goto end; + } + } + +end: + return contains; +} + static inline void bt_plugin_set_add_plugin(struct bt_plugin_set *plugin_set, struct bt_plugin *plugin) { BT_ASSERT(plugin_set); BT_ASSERT(plugin); + + if (bt_plugin_set_contains_plugin(plugin_set, + plugin->info.name->str)) { + goto end; + } + bt_object_get_ref(plugin); g_ptr_array_add(plugin_set->plugins, plugin); BT_LIB_LOGD("Added plugin to plugin set: " "plugin-set-addr=%p, %![plugin-]+l", plugin_set, plugin); + +end: + return; } #endif /* BABELTRACE_PLUGIN_PLUGIN_INTERNAL_H */ diff --git a/tests/bindings/python/bt2/test_plugin.py b/tests/bindings/python/bt2/test_plugin.py index d7e0965b..68400ccb 100644 --- a/tests/bindings/python/bt2/test_plugin.py +++ b/tests/bindings/python/bt2/test_plugin.py @@ -28,15 +28,15 @@ _TEST_PLUGIN_PLUGIN_EXTENSION_BY_OS = {'cygwin': 'dll', 'mingw': 'dll'} class PluginSetTestCase(unittest.TestCase): def test_create(self): - pset = bt2.find_plugins(_TEST_PLUGIN_PLUGINS_PATH) + pset = bt2.find_plugins_in_path(_TEST_PLUGIN_PLUGINS_PATH) self.assertTrue(len(pset) >= 3) def test_getitem(self): - pset = bt2.find_plugins(_TEST_PLUGIN_PLUGINS_PATH) + pset = bt2.find_plugins_in_path(_TEST_PLUGIN_PLUGINS_PATH) self.assertTrue(pset[0].path.startswith(_TEST_PLUGIN_PLUGINS_PATH)) def test_iter(self): - pset = bt2.find_plugins(_TEST_PLUGIN_PLUGINS_PATH) + pset = bt2.find_plugins_in_path(_TEST_PLUGIN_PLUGINS_PATH) names = set() for plugin in pset: @@ -50,16 +50,16 @@ class PluginSetTestCase(unittest.TestCase): class FindPluginsTestCase(unittest.TestCase): def test_find_nonexistent_dir(self): with self.assertRaises(ValueError): - bt2.find_plugins( + bt2.find_plugins_in_path( '/this/does/not/exist/246703df-cb85-46d5-8406-5e8dc4a88b41' ) def test_find_none_existing_dir(self): - plugins = bt2.find_plugins(_TEST_PLUGIN_PLUGINS_PATH, recurse=False) + plugins = bt2.find_plugins_in_path(_TEST_PLUGIN_PLUGINS_PATH, recurse=False) self.assertIsNone(plugins) def test_find_dir(self): - pset = bt2.find_plugins(_TEST_PLUGIN_PLUGINS_PATH) + pset = bt2.find_plugins_in_path(_TEST_PLUGIN_PLUGINS_PATH) self.assertTrue(len(pset) >= 3) def test_find_file(self): @@ -68,7 +68,7 @@ class FindPluginsTestCase(unittest.TestCase): ) plugin_name = 'babeltrace-plugin-utils.{}'.format(extension) path = os.path.join(_TEST_PLUGIN_PLUGINS_PATH, 'utils', '.libs', plugin_name) - pset = bt2.find_plugins(path) + pset = bt2.find_plugins_in_path(path) self.assertTrue(len(pset) == 1) @@ -80,7 +80,7 @@ class FindPluginTestCase(unittest.TestCase): self.assertIsNone(plugin) def test_find_existing(self): - plugin = bt2.find_plugin('ctf') + plugin = bt2.find_plugin('ctf', find_in_user_dir=False, find_in_sys_dir=False) self.assertIsInstance(plugin, bt2.plugin._Plugin) diff --git a/tests/lib/plugin.c b/tests/lib/plugin.c index b6cad1e2..11ec41d1 100644 --- a/tests/lib/plugin.c +++ b/tests/lib/plugin.c @@ -250,8 +250,8 @@ static void test_find(const char *plugin_dir) char *plugin_path; bt_plugin_find_status status; - ok(bt_plugin_find(NON_EXISTING_PATH, BT_FALSE, &plugin) == - BT_PLUGIN_FIND_STATUS_NOT_FOUND, + ok(bt_plugin_find(NON_EXISTING_PATH, BT_TRUE, BT_FALSE, BT_FALSE, + BT_FALSE, BT_FALSE, &plugin) == BT_PLUGIN_FIND_STATUS_NOT_FOUND, "bt_plugin_find() returns BT_PLUGIN_STATUS_NOT_FOUND with an unknown plugin name"); ret = asprintf(&plugin_path, "%s" G_SEARCHPATH_SEPARATOR_S G_DIR_SEPARATOR_S "ec1d09e5-696c-442e-b1c3-f9c6cf7f5958" @@ -263,7 +263,8 @@ static void test_find(const char *plugin_dir) BT_ASSERT(ret > 0 && plugin_path); g_setenv("BABELTRACE_PLUGIN_PATH", plugin_path, 1); plugin = NULL; - status = bt_plugin_find("test_minimal", BT_FALSE, &plugin); + status = bt_plugin_find("test_minimal", BT_TRUE, BT_FALSE, BT_FALSE, + BT_FALSE, BT_FALSE, &plugin); ok(status == BT_PLUGIN_FIND_STATUS_OK, "bt_plugin_find() succeeds with a plugin name it can find"); ok(plugin, "bt_plugin_find() returns a plugin object"); diff --git a/tests/python-plugin-provider/test_python_plugin_provider.py b/tests/python-plugin-provider/test_python_plugin_provider.py index 6a0a6d88..e94fd793 100644 --- a/tests/python-plugin-provider/test_python_plugin_provider.py +++ b/tests/python-plugin-provider/test_python_plugin_provider.py @@ -24,7 +24,7 @@ import os class PythonPluginProviderTestCase(unittest.TestCase): def test_python_plugin_provider(self): path = os.environ['PYTHON_PLUGIN_PROVIDER_TEST_PLUGIN_PATH'] - pset = bt2.find_plugins(path) + pset = bt2.find_plugins_in_path(path) self.assertEqual(len(pset), 1) plugin = pset[0] self.assertEqual(plugin.name, 'sparkling')