feat: plugin store and plugin error

Author: LeoBorai

crates/file-explorer-plugin/src/lib.rs

@@ -23,7 +23,7 @@ use file_explorer::{Entry, FileExplorer};
 use file_explorer_proto::{BreadcrumbItem, DirectoryEntry, DirectoryIndex, EntryType, Sort};
 use file_explorer_ui::Assets;
 use http_server_plugin::config::read_from_path;
-use http_server_plugin::{export_plugin, Function, InvocationError, PluginRegistrar};
+use http_server_plugin::{export_plugin, Plugin, PluginError, PluginRegistrar};
 
 use self::utils::{decode_uri, encode_uri, PERCENT_ENCODE_SET};
 
@@ -61,12 +61,8 @@ struct FileExplorerPlugin {
 }
 
 #[async_trait]
-impl Function for FileExplorerPlugin {
-    async fn call(
-        &self,
-        parts: Parts,
-        body: Bytes,
-    ) -> Result<Response<Full<Bytes>>, InvocationError> {
+impl Plugin for FileExplorerPlugin {
+    async fn call(&self, parts: Parts, body: Bytes) -> Result<Response<Full<Bytes>>, PluginError> {
         self.rt
             .block_on(async move { self.handle(parts, body).await })
     }
@@ -87,7 +83,7 @@ impl FileExplorerPlugin {
         &self,
         parts: Parts,
         body: Bytes,
-    ) -> Result<Response<Full<Bytes>>, InvocationError> {
+    ) -> Result<Response<Full<Bytes>>, PluginError> {
         tracing::info!("Handling request: {:?}", parts);
 
         if parts.uri.path().starts_with("/api/v1") {
@@ -125,7 +121,7 @@ impl FileExplorerPlugin {
         &self,
         parts: Parts,
         body: Bytes,
-    ) -> Result<Response<Full<Bytes>>, InvocationError> {
+    ) -> Result<Response<Full<Bytes>>, PluginError> {
         let path = Self::parse_req_uri(parts.uri.clone()).unwrap();
 
         match parts.method {
@@ -174,7 +170,7 @@ impl FileExplorerPlugin {
         &self,
         parts: Parts,
         body: Bytes,
-    ) -> Result<Response<Full<Bytes>>, InvocationError> {
+    ) -> Result<Response<Full<Bytes>>, PluginError> {
         // Extract the `multipart/form-data` boundary from the headers.
         let boundary = parts
             .headers

crates/http-server-plugin/src/lib.rs

@@ -14,17 +14,13 @@ pub static CORE_VERSION: &str = env!("CARGO_PKG_VERSION");
 pub static RUSTC_VERSION: &str = env!("RUSTC_VERSION");
 
 #[async_trait]
-pub trait Function: Send + Sync {
-    async fn call(
-        &self,
-        parts: Parts,
-        body: Bytes,
-    ) -> Result<Response<Full<Bytes>>, InvocationError>;
+pub trait Plugin: Send + Sync {
+    async fn call(&self, parts: Parts, body: Bytes) -> Result<Response<Full<Bytes>>, PluginError>;
 }
 
 #[derive(Debug)]
-pub enum InvocationError {
-    InvalidArgumentCount { expected: usize, found: usize },
+pub enum PluginError {
+    SpawnError { err: String },
     Other { msg: String },
 }
 
@@ -37,7 +33,7 @@ pub struct PluginDeclaration {
 }
 
 pub trait PluginRegistrar {
-    fn register_function(&mut self, name: &str, function: Arc<dyn Function>);
+    fn register_function(&mut self, name: &str, function: Arc<dyn Plugin>);
 }
 
 #[macro_export]

crates/http-server/src/server/mod.rs

@@ -20,10 +20,8 @@ use tokio::runtime::Runtime;
 use tower::ServiceBuilder;
 use tower_http::cors::{Any, CorsLayer};
 
-use crate::plugins_path;
-
 use self::config::Config;
-use self::plugin::ExternalFunctions;
+use self::plugin::PluginStore;
 
 const ALL_INTERFACES_IPV4: Ipv4Addr = Ipv4Addr::new(0, 0, 0, 0);
 
@@ -39,8 +37,7 @@ impl Server {
     pub async fn run(self, rt: Arc<Runtime>) -> Result<()> {
         let addr = SocketAddr::from((self.config.host, self.config.port));
         let listener = TcpListener::bind(addr).await?;
-        let functions = Arc::new(ExternalFunctions::new());
-        let plugin_library = plugins_path()?.join("file_explorer.plugin.httprs");
+        let plugin_store = Arc::new(PluginStore::new());
         let config = PathBuf::from_str("./config.toml")?;
         let handle = Arc::new(rt.handle().to_owned());
 
@@ -53,15 +50,15 @@ impl Server {
         }
 
         unsafe {
-            functions
-                .load(Arc::clone(&handle), config, plugin_library)
+            plugin_store
+                .load(Arc::clone(&handle), config, "file_explorer.plugin.httprs")
                 .await?;
         }
 
         loop {
             let (stream, _) = listener.accept().await?;
             let io = TokioIo::new(stream);
-            let functions = Arc::clone(&functions);
+            let plugin_store = Arc::clone(&plugin_store);
             let cors = if self.config.cors {
                 Some(
                     CorsLayer::new()
@@ -73,12 +70,12 @@ impl Server {
             };
 
             handle.spawn(async move {
-                let functions = Arc::clone(&functions);
+                let plugin_store = Arc::clone(&plugin_store);
                 let svc = tower::service_fn(|req: Request<Incoming>| async {
                     let (parts, body) = req.into_parts();
                     let body = body.collect().await.unwrap().to_bytes();
 
-                    match functions.call("file-explorer", parts, body).await {
+                    match plugin_store.run("file-explorer", parts, body).await {
                         Ok(res) => Ok::<
                             Response<http_body_util::Full<hyper::body::Bytes>>,
                             Infallible,

crates/http-server/src/server/plugin.rs

@@ -1,6 +1,5 @@
 use std::collections::HashMap;
-use std::ffi::OsStr;
-use std::io;
+use std::io::{Error as IOError, Result as IOResult};
 use std::path::PathBuf;
 use std::sync::Arc;
 
@@ -13,48 +12,44 @@ use libloading::Library;
 use tokio::runtime::Handle;
 use tokio::sync::Mutex;
 
-use http_server_plugin::{
-    Function, InvocationError, PluginDeclaration, CORE_VERSION, RUSTC_VERSION,
-};
+use http_server_plugin::{Plugin, PluginDeclaration, PluginError, CORE_VERSION, RUSTC_VERSION};
 
-/// A proxy object which wraps a [`Function`] and makes sure it can't outlive
+use crate::plugins_path;
+
+/// A proxy object which wraps a [`Plugin`] and makes sure it can't outlive
 /// the library it came from.
 #[derive(Clone)]
-pub struct FunctionProxy {
-    function: Arc<dyn Function>,
+pub struct PluginProxy {
+    function: Arc<dyn Plugin>,
     _lib: Arc<Library>,
 }
 
 #[async_trait]
-impl Function for FunctionProxy {
-    async fn call(
-        &self,
-        parts: Parts,
-        bytes: Bytes,
-    ) -> Result<Response<Full<Bytes>>, InvocationError> {
+impl Plugin for PluginProxy {
+    async fn call(&self, parts: Parts, bytes: Bytes) -> Result<Response<Full<Bytes>>, PluginError> {
         self.function.call(parts, bytes).await
     }
 }
 
-pub struct ExternalFunctions {
+pub struct PluginStore {
+    functions: Mutex<HashMap<String, PluginProxy>>,
     handle: Arc<Handle>,
-    functions: Mutex<HashMap<String, FunctionProxy>>,
     libraries: Mutex<Vec<Arc<Library>>>,
 }
 
-impl Default for ExternalFunctions {
+impl Default for PluginStore {
     fn default() -> Self {
         Self::new()
     }
 }
 
-impl ExternalFunctions {
-    pub fn new() -> ExternalFunctions {
+impl PluginStore {
+    pub fn new() -> Self {
         let handle = Arc::new(Handle::current());
 
-        ExternalFunctions {
-            handle,
+        Self {
             functions: Mutex::new(HashMap::default()),
+            handle,
             libraries: Mutex::new(Vec::new()),
         }
     }
@@ -65,20 +60,26 @@ impl ExternalFunctions {
     ///
     /// This function is unsafe because it loads a shared library and calls
     /// functions from it.
-    pub async unsafe fn load<P: AsRef<OsStr>>(
+    pub async unsafe fn load(
         &self,
         rt_handle: Arc<Handle>,
         config_path: PathBuf,
-        library_path: P,
-    ) -> io::Result<()> {
-        let library = Arc::new(Library::new(library_path).unwrap());
+        plugin_filename: &str,
+    ) -> IOResult<()> {
+        let plugin_path = plugins_path()
+            .map_err(|err| IOError::other(format!("Failed to retrieve plugin path: {err}")))?
+            .join(plugin_filename);
+        let library = Library::new(&plugin_path).map_err(|err| {
+            IOError::other(format!("Failed to load plugin from {plugin_path:?}: {err}"))
+        })?;
+        let library = Arc::new(library);
         let decl = library
             .get::<*mut PluginDeclaration>(b"PLUGIN_DECLARATION\0")
             .unwrap()
             .read();
 
         if decl.rustc_version != RUSTC_VERSION || decl.core_version != CORE_VERSION {
-            return Err(io::Error::new(io::ErrorKind::Other, "Version mismatch"));
+            return Err(IOError::other("Version Mismatch."));
         }
 
         let mut registrar = PluginRegistrar::new(Arc::clone(&library));
@@ -91,28 +92,30 @@ impl ExternalFunctions {
         Ok(())
     }
 
-    async fn get_function(&self, func: &str) -> Option<FunctionProxy> {
+    async fn get(&self, func: &str) -> Option<PluginProxy> {
         self.functions.lock().await.get(func).cloned()
     }
 
-    pub async fn call(
+    pub async fn run(
         &self,
-        func: &str,
+        plugin: &str,
         parts: Parts,
         bytes: Bytes,
-    ) -> Result<Response<Full<Bytes>>, InvocationError> {
-        let function_proxy = self.get_function(func).await.unwrap();
+    ) -> Result<Response<Full<Bytes>>, PluginError> {
+        let function_proxy = self.get(plugin).await.unwrap();
         let join_handle = self
             .handle
             .spawn(async move { function_proxy.call(parts, bytes).await })
             .await;
 
-        join_handle.unwrap()
+        join_handle.map_err(|err| PluginError::SpawnError {
+            err: err.to_string(),
+        })?
     }
 }
 
 struct PluginRegistrar {
-    functions: HashMap<String, FunctionProxy>,
+    functions: HashMap<String, PluginProxy>,
     lib: Arc<Library>,
 }
 
@@ -126,8 +129,8 @@ impl PluginRegistrar {
 }
 
 impl http_server_plugin::PluginRegistrar for PluginRegistrar {
-    fn register_function(&mut self, name: &str, function: Arc<dyn Function>) {
-        let proxy = FunctionProxy {
+    fn register_function(&mut self, name: &str, function: Arc<dyn Plugin>) {
+        let proxy = PluginProxy {
             function,
             _lib: Arc::clone(&self.lib),
         };