openvino-finder: locate plugins.xml

This change adds a `find_plugins_xml` function to `openvino-finder` to
locate the XML configuration describing the plugin libraries. In
previous versions, the `plugins.xml` file was in the same directory as
the shared library; in v2022.3, however, APT installations of OpenVINO
have the `plugins.xml` file in a versioned sub-directory (e.g.,
`openvino-2022.3.0/`). When no path is provided to `Core::new`, this
change will now search for the latest library and discover the
`plugins.xml` file based on that. There are several escape hatches for
specifying the path directly: pass the path directly to `Core::new` or
set the `OPENVINO_PLUGINS_XML` environment variable.

Author: abrown

Cargo.lock

@@ -11,6 +11,17 @@ use std::env;
 use std::fs;
 use std::path::{Path, PathBuf};
 
+// We search for the library in various different places and early-return if we find it.
+macro_rules! check_and_return {
+    ($path: expr) => {
+        log::debug!("Searching in: {}", $path.display());
+        if $path.is_file() {
+            log::info!("Found library at path: {}", $path.display());
+            return Some($path);
+        }
+    };
+}
+
 /// Find the path to an OpenVINO library. This will try:
 /// - the `OPENVINO_INSTALL_DIR` environment variable with several subdirectories appended
 /// - the `INTEL_OPENVINO_DIR` environment variable with several subdirectories appended
@@ -25,17 +36,6 @@ pub fn find(library_name: &str) -> Option<PathBuf> {
     );
     log::info!("Attempting to find library: {}", file);
 
-    // We search for the library in various different places and early-return if we find it.
-    macro_rules! check_and_return {
-        ($path: expr) => {
-            log::debug!("Searching in: {}", $path.display());
-            if $path.is_file() {
-                log::info!("Found library at path: {}", $path.display());
-                return Some($path);
-            }
-        };
-    }
-
     // Search using the `OPENVINO_BUILD_DIR` environment variable; this may be set by users of the
     // `openvino-rs` library.
     if let Some(build_dir) = env::var_os(ENV_OPENVINO_BUILD_DIR) {
@@ -112,6 +112,7 @@ pub fn find(library_name: &str) -> Option<PathBuf> {
 const ENV_OPENVINO_INSTALL_DIR: &str = "OPENVINO_INSTALL_DIR";
 const ENV_OPENVINO_BUILD_DIR: &str = "OPENVINO_BUILD_DIR";
 const ENV_INTEL_OPENVINO_DIR: &str = "INTEL_OPENVINO_DIR";
+const ENV_OPENVINO_PLUGINS_XML: &str = "OPENVINO_PLUGINS_XML";
 
 cfg_if! {
     if #[cfg(any(target_os = "linux"))] {
@@ -163,6 +164,47 @@ const KNOWN_BUILD_SUBDIRECTORIES: &[&str] = &[
     "temp/tbb/lib",
 ];
 
+/// Find the path to the `plugins.xml` configuration file.
+///
+/// OpenVINO records the location of its plugin libraries in a `plugins.xml` file. This file is
+/// examined by OpenVINO on initialization; not knowing the location to this file can lead to
+/// inference errors later (e.g., `Inference(GeneralError)`). OpenVINO uses the `plugins.xml` file
+/// to load target-specific libraries on demand for performing inference. The `plugins.xml` file
+/// maps targets (e.g., CPU) to their target-specific implementation library.
+///
+/// This file can be found in multiple locations, depending on the installation mechanism. For TAR
+/// installations, it is found in the same directory as the OpenVINO libraries themselves. For
+/// DEB/RPM installations, it is found in a version-suffixed directory beside the OpenVINO libraries
+/// (e.g., `openvino-2022.3.0/plugins.xml`).
+///
+/// This function will check:
+/// - the `OPENVINO_PLUGINS_XML` environment variable--this is specific to this library
+/// - the same directory as the `openvino_c` shared library, as discovered by [find]
+/// - the latest version directory beside the `openvino_c` shared library (i.e.,
+///   `openvino-<version>/`)
+pub fn find_plugins_xml() -> Option<PathBuf> {
+    const FILE_NAME: &str = "plugins.xml";
+
+    // The `OPENVINO_PLUGINS_XML` should point directly to the file.
+    if let Some(path) = env::var_os(ENV_OPENVINO_PLUGINS_XML) {
+        return Some(PathBuf::from(path));
+    }
+
+    // Check in the same directory as the `openvino_c` library; e.g.,
+    // `/opt/intel/openvino_.../runtime/lib/intel64/plugins.xml`.
+    let library = find("openvino_c")?;
+    let library_parent_dir = library.parent()?;
+    check_and_return!(library_parent_dir.join(FILE_NAME));
+
+    // Check in OpenVINO's special system installation directory; e.g.,
+    // `/usr/lib/x86_64-linux-gnu/openvino-2022.3.0/plugins.xml`.
+    let filenames = list_directory(library_parent_dir)?;
+    let versions = get_suffixes(filenames, "openvino-");
+    let path = build_latest_version(library_parent_dir, "openvino-", versions)?.join("plugins.xml");
+    check_and_return!(path);
+
+    None
+}
 
 #[inline]
 fn list_directory(dir: &Path) -> Option<impl IntoIterator<Item = String>> {
@@ -224,4 +266,19 @@ mod test {
             ))
         );
     }
+
+    /// This test shows how the finder would discover the latest `plugins.xml` directory on an
+    /// APT installation.
+    #[test]
+    fn find_latest_plugin_xml() {
+        let path = build_latest_version(
+            &PathBuf::from("/usr/lib/x86_64-linux-gnu"),
+            "openvino-",
+            vec!["2022.3.0".into(), "2023.1.0".into(), "2022.1.0".into()],
+        );
+        assert_eq!(
+            path,
+            Some(PathBuf::from("/usr/lib/x86_64-linux-gnu/openvino-2023.1.0"))
+        );
+    }
 }

crates/openvino-finder/src/lib.rs

@@ -16,6 +16,7 @@ exclude = [
 
 [dependencies]
 openvino-sys = { path = "../openvino-sys", version = "0.4.2" }
+openvino-finder = { path = "../openvino-finder", version = "0.4.2" }
 thiserror = "1.0.20"
 
 [dev-dependencies]

crates/openvino/Cargo.toml

@@ -30,14 +30,11 @@ impl Core {
         openvino_sys::library::load().map_err(LoadingError::SystemFailure)?;
 
         let file = match xml_config_file {
-            None => format!(
-                "{}/plugins.xml",
-                openvino_sys::library::find()
-                    .ok_or(LoadingError::CannotFindPath)?
-                    .parent()
-                    .ok_or(LoadingError::NoParentDirectory)?
-                    .display()
-            ),
+            None => openvino_finder::find_plugins_xml()
+                .ok_or(LoadingError::CannotFindPluginPath)?
+                .to_str()
+                .ok_or(LoadingError::CannotStringifyPath)?
+                .to_string(),
             Some(f) => f.to_string(),
         };
         let mut instance = std::ptr::null_mut();

crates/openvino/src/core.rs

@@ -79,7 +79,9 @@ pub enum LoadingError {
     #[error("system failed to load shared libraries (see https://github.com/intel/openvino-rs/blob/main/crates/openvino-finder): {0}")]
     SystemFailure(String),
     #[error("cannot find path to shared libraries (see https://github.com/intel/openvino-rs/blob/main/crates/openvino-finder)")]
-    CannotFindPath,
-    #[error("no parent directory found for shared library path")]
-    NoParentDirectory,
+    CannotFindLibraryPath,
+    #[error("cannot find path to XML plugin configuration (see https://github.com/intel/openvino-rs/blob/main/crates/openvino-finder)")]
+    CannotFindPluginPath,
+    #[error("unable to convert path to a UTF-8 string (see https://doc.rust-lang.org/std/path/struct.Path.html#method.to_str)")]
+    CannotStringifyPath,
 }