feat: load service as library

Author: LeoBorai

Cargo.lock

@@ -9,4 +9,7 @@ publish = false
 crate-type = ["cdylib"]
 
 [dependencies]
+http-body-util = { workspace = true }
+hyper = { workspace = true }
+
 http-server-plugin = { workspace = true }

crates/file-explorer/Cargo.toml

@@ -1,11 +1,18 @@
+use std::sync::Arc;
+
+use http_body_util::Full;
+use hyper::body::{Bytes, Incoming};
+use hyper::{Request, Response};
+
 use http_server_plugin::{export_plugin, Function, InvocationError, PluginRegistrar};
 
 export_plugin!(register);
 
+#[allow(improper_ctypes_definitions)]
 extern "C" fn register(registrar: &mut dyn PluginRegistrar) {
     registrar.register_function(
         "file-explorer",
-        Box::new(FileExplorer {
+        Arc::new(FileExplorer {
             path: String::from("/"),
         }),
     );
@@ -16,7 +23,7 @@ pub struct FileExplorer {
 }
 
 impl Function for FileExplorer {
-    fn call(&self, _args: &[f64]) -> Result<f64, InvocationError> {
-        Ok(0.0)
+    fn call(&self, _: Request<Incoming>) -> Result<Response<Full<Bytes>>, InvocationError> {
+        Ok(Response::new(Full::new(Bytes::from("Hello, World!"))))
     }
 }

crates/file-explorer/src/lib.rs

@@ -10,5 +10,9 @@ keywords = ["sdk", "http", "server", "plugin", "dll"]
 license = "MIT OR Apache-2.0"
 readme = "README.md"
 
+[dependencies]
+http-body-util = { workspace = true }
+hyper = { workspace = true }
+
 [build-dependencies]
 rustc_version = { workspace = true }

crates/http-server-plugin/Cargo.toml

@@ -1,13 +1,14 @@
+use std::sync::Arc;
+
+use http_body_util::Full;
+use hyper::body::{Bytes, Incoming};
+use hyper::{Request, Response};
+
 pub static CORE_VERSION: &str = env!("CARGO_PKG_VERSION");
 pub static RUSTC_VERSION: &str = env!("RUSTC_VERSION");
 
-pub trait Function {
-    fn call(&self, args: &[f64]) -> Result<f64, InvocationError>;
-
-    /// Help text that may be used to display information about this function.
-    fn help(&self) -> Option<&str> {
-        None
-    }
+pub trait Function: Send + Sync {
+    fn call(&self, req: Request<Incoming>) -> Result<Response<Full<Bytes>>, InvocationError>;
 }
 
 #[derive(Debug)]
@@ -24,15 +25,15 @@ pub struct PluginDeclaration {
 }
 
 pub trait PluginRegistrar {
-    fn register_function(&mut self, name: &str, function: Box<dyn Function>);
+    fn register_function(&mut self, name: &str, function: Arc<dyn Function>);
 }
 
 #[macro_export]
 macro_rules! export_plugin {
     ($register:expr) => {
         #[doc(hidden)]
         #[no_mangle]
-        pub static plugin_declaration: $crate::PluginDeclaration = $crate::PluginDeclaration {
+        pub static PLUGIN_DECLARATION: $crate::PluginDeclaration = $crate::PluginDeclaration {
             rustc_version: $crate::RUSTC_VERSION,
             core_version: $crate::CORE_VERSION,
             register: $register,

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

@@ -3,31 +3,14 @@ pub mod config;
 pub mod plugin;
 pub mod server;
 
-use std::{path::PathBuf, process::exit, str::FromStr};
+use std::process::exit;
 
 use anyhow::Result;
 
-use crate::plugin::ExternalFunctions;
-
 use self::server::Server;
 
 #[tokio::main]
 async fn main() -> Result<()> {
-    let mut functions = ExternalFunctions::new();
-    let plugin_library = PathBuf::from_str("./target/debug/libfile_explorer.dylib").unwrap();
-
-    unsafe {
-        functions
-            .load(plugin_library)
-            .expect("Function loading failed");
-    }
-
-    let result = functions
-        .call("file-explorer", &[])
-        .expect("Invocation failed");
-
-    println!("file-explorer() = {}", result);
-
     match Server::run().await {
         Ok(_) => {
             println!("Server exited successfuly");

crates/http-server/src/main.rs

@@ -1,8 +1,11 @@
 use std::collections::HashMap;
 use std::ffi::OsStr;
 use std::io;
-use std::rc::Rc;
+use std::sync::{Arc, Mutex};
 
+use http_body_util::Full;
+use hyper::body::{Bytes, Incoming};
+use hyper::{Request, Response};
 use libloading::Library;
 
 use http_server_plugin::{
@@ -12,74 +15,83 @@ use http_server_plugin::{
 /// A proxy object which wraps a [`Function`] and makes sure it can't outlive
 /// the library it came from.
 pub struct FunctionProxy {
-    function: Box<dyn Function>,
-    _lib: Rc<Library>,
+    function: Arc<dyn Function>,
+    _lib: Arc<Library>,
 }
 
 impl Function for FunctionProxy {
-    fn call(&self, args: &[f64]) -> Result<f64, InvocationError> {
-        self.function.call(args)
-    }
-
-    fn help(&self) -> Option<&str> {
-        self.function.help()
+    fn call(&self, req: Request<Incoming>) -> Result<Response<Full<Bytes>>, InvocationError> {
+        self.function.call(req)
     }
 }
 
 #[derive(Default)]
 pub struct ExternalFunctions {
-    functions: HashMap<String, FunctionProxy>,
-    libraries: Vec<Rc<Library>>,
+    functions: Mutex<HashMap<String, FunctionProxy>>,
+    libraries: Mutex<Vec<Arc<Library>>>,
 }
 
 impl ExternalFunctions {
     pub fn new() -> ExternalFunctions {
         ExternalFunctions::default()
     }
 
-    pub unsafe fn load<P: AsRef<OsStr>>(&mut self, library_path: P) -> io::Result<()> {
-        // load the library into memory
-        let library = Rc::new(Library::new(library_path).unwrap());
-
-        // get a pointer to the plugin_declaration symbol.
+    /// Loads a plugin from the given path.
+    ///
+    /// # Safety
+    ///
+    /// This function is unsafe because it loads a shared library and calls
+    /// functions from it.
+    pub unsafe fn load<P: AsRef<OsStr>>(&self, library_path: P) -> io::Result<()> {
+        let library = Arc::new(Library::new(library_path).unwrap());
         let decl = library
             .get::<*mut PluginDeclaration>(b"plugin_declaration\0")
             .unwrap()
             .read();
 
-        // version checks to prevent accidental ABI incompatibilities
         if decl.rustc_version != RUSTC_VERSION || decl.core_version != CORE_VERSION {
             return Err(io::Error::new(io::ErrorKind::Other, "Version mismatch"));
         }
 
-        let mut registrar = PluginRegistrar::new(Rc::clone(&library));
+        let mut registrar = PluginRegistrar::new(Arc::clone(&library));
 
         (decl.register)(&mut registrar);
 
-        // add all loaded plugins to the functions map
-        self.functions.extend(registrar.functions);
-        // and make sure ExternalFunctions keeps a reference to the library
-        self.libraries.push(library);
+        self.functions
+            .lock()
+            .expect("Cannot lock Mutex")
+            .extend(registrar.functions);
+
+        self.libraries
+            .lock()
+            .expect("Cannot lock Mutex")
+            .push(library);
 
         Ok(())
     }
 
-    pub fn call(&self, function: &str, arguments: &[f64]) -> Result<f64, InvocationError> {
+    pub fn call(
+        &self,
+        function: &str,
+        req: Request<Incoming>,
+    ) -> Result<Response<Full<Bytes>>, InvocationError> {
         self.functions
+            .lock()
+            .expect("Cannot lock Mutex")
             .get(function)
             .ok_or_else(|| format!("\"{}\" not found", function))
             .unwrap()
-            .call(arguments)
+            .call(req)
     }
 }
 
 struct PluginRegistrar {
     functions: HashMap<String, FunctionProxy>,
-    lib: Rc<Library>,
+    lib: Arc<Library>,
 }
 
 impl PluginRegistrar {
-    fn new(lib: Rc<Library>) -> PluginRegistrar {
+    fn new(lib: Arc<Library>) -> PluginRegistrar {
         PluginRegistrar {
             lib,
             functions: HashMap::default(),
@@ -88,10 +100,10 @@ impl PluginRegistrar {
 }
 
 impl http_server_plugin::PluginRegistrar for PluginRegistrar {
-    fn register_function(&mut self, name: &str, function: Box<dyn Function>) {
+    fn register_function(&mut self, name: &str, function: Arc<dyn Function>) {
         let proxy = FunctionProxy {
             function,
-            _lib: Rc::clone(&self.lib),
+            _lib: Arc::clone(&self.lib),
         };
 
         self.functions.insert(name.to_string(), proxy);

crates/http-server/src/plugin.rs

@@ -1,31 +1,34 @@
-use std::{convert::Infallible, net::SocketAddr};
+use std::{convert::Infallible, net::SocketAddr, path::PathBuf, str::FromStr, sync::Arc};
 
 use anyhow::Result;
 use http_body_util::Full;
-use hyper::{
-    body::{Bytes, Incoming},
-    server::conn::http1,
-    Method, Request, Response,
-};
+use hyper::{body::Bytes, server::conn::http1, Method, Response};
 use hyper_util::{rt::TokioIo, service::TowerToHyperService};
 use tokio::net::TcpListener;
 use tower::ServiceBuilder;
 use tower_http::cors::{Any, CorsLayer};
 
-async fn hello(_: Request<Incoming>) -> Result<Response<Full<Bytes>>, Infallible> {
-    Ok(Response::new(Full::new(Bytes::from("Hello, World!"))))
-}
+use crate::plugin::ExternalFunctions;
 
 pub struct Server {}
 
 impl Server {
     pub async fn run() -> Result<()> {
         let addr = SocketAddr::from(([127, 0, 0, 1], 3000));
         let listener = TcpListener::bind(addr).await?;
+        let functions = Arc::new(ExternalFunctions::new());
+        let plugin_library = PathBuf::from_str("./target/debug/libfile_explorer.dylib").unwrap();
+
+        unsafe {
+            functions
+                .load(plugin_library)
+                .expect("Function loading failed");
+        }
 
         loop {
             let (stream, _) = listener.accept().await?;
             let io = TokioIo::new(stream);
+            let functions = Arc::clone(&functions);
 
             let cors = CorsLayer::new()
                 // allow `GET` and `POST` when accessing the resource
@@ -34,8 +37,23 @@ impl Server {
                 .allow_origin(Any);
 
             tokio::spawn(async move {
+                let functions = Arc::clone(&functions);
+
                 // N.B. should use tower service_fn here, since it's reuqired to be implemented tower Service trait before convert to hyper Service!
-                let svc = tower::service_fn(hello);
+                let svc = tower::service_fn(|req| async {
+                    match functions.call("file-explorer", req) {
+                        Ok(res) => Ok::<
+                            Response<http_body_util::Full<hyper::body::Bytes>>,
+                            Infallible,
+                        >(res),
+                        Err(err) => {
+                            eprintln!("Error: {:?}", err);
+                            Ok(Response::new(Full::new(Bytes::from(
+                                "Internal Server Error",
+                            ))))
+                        }
+                    }
+                });
                 let svc = ServiceBuilder::new().layer(cors).service(svc);
                 // Convert it to hyper service
                 let svc = TowerToHyperService::new(svc);