fix: experiment segfault

Cargo.toml

@@ -1,9 +1,10 @@
 [workspace]
 members = [
-    "crates/file-explorer",
-    "crates/file-explorer-plugin",
-    "crates/file-explorer-proto",
-    "crates/file-explorer-ui",
+    # "crates/file-explorer",
+    # "crates/file-explorer-plugin",
+    # "crates/file-explorer-proto",
+    # "crates/file-explorer-ui",
+    "crates/hello-world-plugin",
     "crates/http-server",
     "crates/http-server-plugin",
 ]

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

@@ -62,7 +62,7 @@ struct FileExplorerPlugin {
 
 #[async_trait]
 impl Plugin for FileExplorerPlugin {
-    async fn call(&self, parts: Parts, body: Bytes) -> Result<Response<Full<Bytes>>, PluginError> {
+    fn call(&self, parts: Parts, body: Bytes) -> Result<Response<Full<Bytes>>, PluginError> {
         self.rt
             .block_on(async move { self.handle(parts, body).await })
     }
@@ -84,37 +84,38 @@ impl FileExplorerPlugin {
         parts: Parts,
         body: Bytes,
     ) -> Result<Response<Full<Bytes>>, PluginError> {
-        tracing::info!("Handling request: {:?}", parts);
-
-        if parts.uri.path().starts_with("/api/v1") {
-            self.handle_api(parts, body).await
-        } else {
-            let path = parts.uri.path();
-            let path = path.strip_prefix('/').unwrap_or(path);
-
-            if let Some(file) = Assets::get(path) {
-                let content_type = mime_guess::from_path(path).first_or_octet_stream();
-                let content_type = HeaderValue::from_str(content_type.as_ref()).unwrap();
-                let body = Full::new(Bytes::from(file.data.to_vec()));
-                let mut response = Response::new(body);
-                let mut headers = response.headers().clone();
-
-                headers.append(CONTENT_TYPE, content_type);
-                *response.headers_mut() = headers;
-
-                return Ok(response);
-            }
-
-            let index = Assets::get("index.html").unwrap();
-            let body = Full::new(Bytes::from(index.data.to_vec()));
-            let mut response = Response::new(body);
-            let mut headers = response.headers().clone();
-
-            headers.append(CONTENT_TYPE, "text/html".try_into().unwrap());
-            *response.headers_mut() = headers;
-
-            Ok(response)
-        }
+        Ok(Response::new(Full::new(Bytes::from("Unsupported method"))))
+        // tracing::info!("Handling request: {:?}", parts);
+
+        // if parts.uri.path().starts_with("/api/v1") {
+        //     self.handle_api(parts, body).await
+        // } else {
+        //     let path = parts.uri.path();
+        //     let path = path.strip_prefix('/').unwrap_or(path);
+
+        //     if let Some(file) = Assets::get(path) {
+        //         let content_type = mime_guess::from_path(path).first_or_octet_stream();
+        //         let content_type = HeaderValue::from_str(content_type.as_ref()).unwrap();
+        //         let body = Full::new(Bytes::from(file.data.to_vec()));
+        //         let mut response = Response::new(body);
+        //         let mut headers = response.headers().clone();
+
+        //         headers.append(CONTENT_TYPE, content_type);
+        //         *response.headers_mut() = headers;
+
+        //         return Ok(response);
+        //     }
+
+        //     let index = Assets::get("index.html").unwrap();
+        //     let body = Full::new(Bytes::from(index.data.to_vec()));
+        //     let mut response = Response::new(body);
+        //     let mut headers = response.headers().clone();
+
+        //     headers.append(CONTENT_TYPE, "text/html".try_into().unwrap());
+        //     *response.headers_mut() = headers;
+
+        //     Ok(response)
+        // }
     }
 
     async fn handle_api(

crates/hello-world-plugin/Cargo.toml

@@ -0,0 +1,25 @@
+[package]
+name = "hello-world-plugin"
+version = "0.0.0"
+authors = ["Esteban Borai <[email protected]>"]
+edition = "2021"
+publish = false
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+anyhow = { workspace = true }
+async-trait = { workspace = true }
+bytes = { workspace = true }
+futures = { workspace = true }
+http = { workspace = true }
+http-body-util = { workspace = true }
+hyper = { workspace = true }
+serde = { workspace = true, features = ["derive"] }
+serde_json = { workspace = true }
+tokio = { workspace = true, features = ["fs", "rt-multi-thread", "signal", "macros"] }
+tracing = { workspace = true }
+tracing-subscriber = { workspace = true, features = ["env-filter"] }
+
+http-server-plugin = { workspace = true }

crates/hello-world-plugin/Makefile

@@ -0,0 +1,8 @@
+.PHONY: default
+
+default:
+	@echo No default target.
+
+release:
+	@echo Building hello-world-plugin
+	cargo b --release

crates/hello-world-plugin/src/lib.rs

@@ -0,0 +1,57 @@
+use std::path::PathBuf;
+use std::sync::Arc;
+
+use anyhow::Result;
+use async_trait::async_trait;
+use http::request::Parts;
+use http_body_util::Full;
+use hyper::body::Bytes;
+use hyper::Response;
+use tokio::runtime::Handle;
+
+use http_server_plugin::{export_plugin, Plugin, PluginError, PluginRegistrar};
+
+export_plugin!(register);
+
+const PLUGIN_NAME: &str = "hello-world";
+
+#[allow(improper_ctypes_definitions)]
+extern "C" fn register(_: PathBuf, rt: Arc<Handle>, registrar: &mut dyn PluginRegistrar) {
+    tracing_subscriber::fmt()
+        .with_max_level(tracing::Level::INFO)
+        .init();
+
+    registrar.register_function(
+        PLUGIN_NAME,
+        Arc::new(HelloWorldPlugin::new(rt)),
+    );
+}
+
+struct HelloWorldPlugin {
+    rt: Arc<Handle>,
+}
+
+#[async_trait]
+impl Plugin for HelloWorldPlugin {
+    #[no_mangle]
+    fn call(&self, parts: Parts, body: Bytes) -> Result<Response<Full<Bytes>>, PluginError> {
+        println!("Test block on:");
+        self.handle(parts, body)
+    }
+}
+
+impl HelloWorldPlugin {
+    fn new(rt: Arc<Handle>) -> Self {
+        Self {
+            rt,
+        }
+    }
+
+    fn handle(
+        &self,
+        _: Parts,
+        _: Bytes,
+    ) -> Result<Response<Full<Bytes>>, PluginError> {
+        Ok(Response::new(Full::new(Bytes::from("Hello World"))))
+    }
+}

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

@@ -3,7 +3,6 @@ pub mod config;
 use std::path::PathBuf;
 use std::sync::Arc;
 
-use async_trait::async_trait;
 use http::request::Parts;
 use http_body_util::Full;
 use hyper::body::Bytes;
@@ -13,9 +12,8 @@ use tokio::runtime::Handle;
 pub static CORE_VERSION: &str = env!("CARGO_PKG_VERSION");
 pub static RUSTC_VERSION: &str = env!("RUSTC_VERSION");
 
-#[async_trait]
 pub trait Plugin: Send + Sync {
-    async fn call(&self, parts: Parts, body: Bytes) -> Result<Response<Full<Bytes>>, PluginError>;
+    fn call(&self, parts: Parts, body: Bytes) -> Result<Response<Full<Bytes>>, PluginError>;
 }
 
 #[derive(Debug)]

crates/http-server/src/bin/cli/command/setup.rs

@@ -1,4 +1,4 @@
-use std::fs::{create_dir_all, write};
+use std::fs::{create_dir_all, remove_file, write};
 
 use anyhow::Result;
 use clap::Parser;
@@ -33,6 +33,14 @@ impl SetupOpt {
                 "Installing File Explorer Plugin at: {}",
                 file_explorer_plugin_path.display()
             );
+
+            if let Err(err) = remove_file(&file_explorer_plugin_path) {
+                eprint!(
+                    "Failed to delete previous plugin version at {}\nError: {err}",
+                    file_explorer_plugin_path.display()
+                );
+            }
+
             write(&file_explorer_plugin_path, FILE_EXPLORER_PLUGIN_BYTES)?;
         }
 

crates/http-server/src/lib.rs

@@ -9,7 +9,7 @@
 pub const HTTP_SERVER_PLUGINS_DIRNAME: &str = "plugins";
 pub const DEFAULT_PLUGIN_NAME: &str = "file_explorer.plugin.httprs";
 pub const FILE_EXPLORER_PLUGIN_BYTES: &[u8] =
-    include_bytes!("../inline/file_explorer.plugin.httprs");
+    include_bytes!("../../../target/release/libhello_world_plugin.dylib");
 
 pub fn install_path() -> Result<PathBuf> {
     let Some(home) = home_dir() else {

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

@@ -74,8 +74,8 @@ impl Server {
                 let svc = tower::service_fn(|req: Request<Incoming>| async {
                     let (parts, body) = req.into_parts();
                     let body = body.collect().await.unwrap().to_bytes();
-
-                    match plugin_store.run("file-explorer", parts, body).await {
+                    println!("Exec: hello-world");
+                    match plugin_store.run("hello-world", parts, body).await {
                         Ok(res) => Ok::<
                             Response<http_body_util::Full<hyper::body::Bytes>>,
                             Infallible,

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

@@ -26,8 +26,9 @@ pub struct PluginProxy {
 
 #[async_trait]
 impl Plugin for PluginProxy {
-    async fn call(&self, parts: Parts, bytes: Bytes) -> Result<Response<Full<Bytes>>, PluginError> {
-        self.function.call(parts, bytes).await
+    #[no_mangle]
+    fn call(&self, parts: Parts, bytes: Bytes) -> Result<Response<Full<Bytes>>, PluginError> {
+        self.function.call(parts, bytes)
     }
 }
 
@@ -103,14 +104,7 @@ impl PluginStore {
         bytes: Bytes,
     ) -> 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.map_err(|err| PluginError::SpawnError {
-            err: err.to_string(),
-        })?
+        function_proxy.call(parts, bytes)
     }
 }