lib: add bt_plugin_find_all()
authorPhilippe Proulx <eeppeliteloop@gmail.com>
Sat, 20 Jul 2019 17:48:17 +0000 (13:48 -0400)
committerPhilippe Proulx <eeppeliteloop@gmail.com>
Wed, 24 Jul 2019 14:33:33 +0000 (10:33 -0400)
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 <eeppeliteloop@gmail.com>
Change-Id: Icad1387d64d15a639da107ab1ba30e5a53136ced
Reviewed-on: https://review.lttng.org/c/babeltrace/+/1729
Tested-by: jenkins <jenkins@lttng.org>
include/babeltrace2/plugin/plugin-const.h
src/bindings/python/bt2/bt2/native_bt_plugin.i
src/bindings/python/bt2/bt2/plugin.py
src/lib/plugin/plugin.c
src/lib/plugin/plugin.h
tests/bindings/python/bt2/test_plugin.py
tests/lib/plugin.c
tests/python-plugin-provider/test_python_plugin_provider.py

index 11a6a01f5478757627f11c34136c9b1576400a03..65b66defaa429f9cf68d54c3d51cf62169099c68 100644 (file)
@@ -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,
index 4cdf9a41308f939b65dd80710f08333ef93ae62d..a0c2b3f1040b3d78d870bef0ca66b83e092f435c 100644 (file)
@@ -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)
index 5198bdf32abfa3bb8e9ba9a86e397af5f9bc1154..597f38f24e8f3405990b91fa7eebb17821e70df1 100644 (file)
@@ -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
index 5537cb0d115fe2176123556605c831a1510b28c0..33ba6c9d8a473af83e06e82f192c43432092a628 100644 (file)
@@ -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);
        }
index 616987223ca9023bfea2d64dd7da70ae2cc92b21..ba4f45516ed921a2e58c36192aa8a588939a89c4 100644 (file)
@@ -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 */
index d7e0965b1f21c3d98b2ff0ccdf23b8df2663b38c..68400ccbe7e2d4169eb25998502e54f68d3e73b3 100644 (file)
@@ -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)
 
 
index b6cad1e2c76885a33959cece85806715fd074b33..11ec41d12025f39d2c270afaac4182c8b1e65657 100644 (file)
@@ -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");
index 6a0a6d886629e2f7210ad5b4049c5b2bbc633471..e94fd793392764cd3802569ef93a0efd3030b351 100644 (file)
@@ -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')
This page took 0.033224 seconds and 4 git commands to generate.