Merge branch 'develop' into hyperwallet-client_lib

Conflicts:
      Cargo.lock

Author: nick1udwig

Cargo.lock

@@ -1,7 +1,7 @@
 [package]
 name = "hyperware_process_lib"
 authors = ["Sybil Technologies AG"]
-version = "1.2.0"
+version = "2.0.1"
 edition = "2021"
 description = "A library for writing Hyperware processes in Rust."
 homepage = "https://hyperware.ai"
@@ -44,4 +44,4 @@ tracing = { version = "0.1", optional = true }
 tracing-error = { version = "0.2", optional = true }
 tracing-subscriber = { version = "0.3", features = ["env-filter", "json", "std"], optional = true }
 url = "2.4.1"
-wit-bindgen = "0.36.0"
+wit-bindgen = "0.42.1"

Cargo.toml

@@ -7,3 +7,13 @@ Library of functions for more ergonomic Hyperware Rust process development.
 [Crate can be found here](https://crates.io/crates/hyperware_process_lib).
 
 See the [Hyperware Book](https://book.hyperware.ai) for a guide on how to use this library to write Hyperware apps in Rust.
+
+## Dependencies
+
+`process_lib` v`2.x.y` uses [`wit-bindgen`](https://github.com/bytecodealliance/wit-bindgen) v`0.42.1`.
+Processes depending on `process_lib` must also use that version.
+
+`process_lib` version | `wit-bindgen` version
+--------------------- | ---------------------
+`2.x.y`               | `0.42.1`
+`1.x.y`               | `0.36.0`

README.md

@@ -878,19 +878,17 @@ impl HttpServer {
         Ok(())
     }
 
-    /// Serve static files from a given directory by binding all of them
-    /// in http-server to their filesystem path.
-    ///
-    /// The directory is relative to the `pkg` folder within this package's drive.
-    ///
-    /// The config `static_content` field will be ignored in favor of the files' contents.
-    /// An error will be returned if the file does not exist.
-    pub fn serve_ui(
+    /// Helper function to traverse a UI directory and apply an operation to each file.
+    /// This is used by both serve_ui and unserve_ui to avoid code duplication.
+    fn traverse_ui_directory<F>(
         &mut self,
         directory: &str,
-        roots: Vec<&str>,
-        config: HttpBindingConfig,
-    ) -> Result<(), HttpServerError> {
+        roots: &[&str],
+        mut file_handler: F,
+    ) -> Result<(), HttpServerError>
+    where
+        F: FnMut(&mut Self, &str, &[&str], bool) -> Result<(), HttpServerError>,
+    {
         let our = crate::our();
         let initial_path = format!("{}/pkg/{}", our.package_id(), directory);
 
@@ -927,22 +925,17 @@ impl HttpServer {
                         queue.push_back(entry.path);
                     }
                     FileType::File => {
-                        // if it's a file, serve it statically at its path
-                        // if it's `index.html`, serve additionally as the root
-                        if entry.path.ends_with("index.html") {
-                            for root in &roots {
-                                self.serve_file_raw_path(
-                                    &entry.path,
-                                    vec![root, &entry.path.replace(&initial_path, "")],
-                                    config.clone(),
-                                )?;
+                        let relative_path = entry.path.replace(&initial_path, "");
+                        let is_index = entry.path.ends_with("index.html");
+
+                        // Call the handler with the file path and whether it's an index file
+                        file_handler(self, &entry.path, &[relative_path.as_str()], is_index)?;
+
+                        // If it's an index file, also handle the root paths
+                        if is_index {
+                            for root in roots {
+                                file_handler(self, &entry.path, &[root], true)?;
                             }
-                        } else {
-                            self.serve_file_raw_path(
-                                &entry.path,
-                                vec![&entry.path.replace(&initial_path, "")],
-                                config.clone(),
-                            )?;
                         }
                     }
                     _ => {
@@ -955,6 +948,40 @@ impl HttpServer {
         Ok(())
     }
 
+    /// Serve static files from a given directory by binding all of them
+    /// in http-server to their filesystem path.
+    ///
+    /// The directory is relative to the `pkg` folder within this package's drive.
+    ///
+    /// The config `static_content` field will be ignored in favor of the files' contents.
+    /// An error will be returned if the file does not exist.
+    pub fn serve_ui(
+        &mut self,
+        directory: &str,
+        roots: Vec<&str>,
+        config: HttpBindingConfig,
+    ) -> Result<(), HttpServerError> {
+        self.traverse_ui_directory(directory, &roots, |server, file_path, paths, _is_index| {
+            server.serve_file_raw_path(file_path, paths.to_vec(), config.clone())
+        })
+    }
+
+    /// Unserve static files from a given directory by unbinding all of them
+    /// from http-server that were previously bound by serve_ui.
+    ///
+    /// The directory is relative to the `pkg` folder within this package's drive.
+    ///
+    /// This mirrors the logic of serve_ui but calls unbind_http_path instead.
+    pub fn unserve_ui(&mut self, directory: &str, roots: Vec<&str>) -> Result<(), HttpServerError> {
+        self.traverse_ui_directory(directory, &roots, |server, _file_path, paths, _is_index| {
+            // Unbind each path that was bound
+            for path in paths {
+                server.unbind_http_path(*path)?;
+            }
+            Ok(())
+        })
+    }
+
     /// Handle a WebSocket open event from the HTTP server.
     pub fn handle_websocket_open(&mut self, path: &str, channel_id: u32) {
         self.ws_channels

src/http/server.rs

@@ -1536,36 +1536,20 @@ impl Serialize for CacherRequest {
         S: Serializer,
     {
         match self {
-            CacherRequest::GetManifest => {
-                let mut map = serializer.serialize_map(Some(1))?;
-                map.serialize_entry("GetManifest", &())?;
-                map.end()
-            }
+            CacherRequest::GetManifest => serializer.serialize_str("GetManifest"),
             CacherRequest::GetLogCacheContent(path) => {
                 let mut map = serializer.serialize_map(Some(1))?;
                 map.serialize_entry("GetLogCacheContent", path)?;
                 map.end()
             }
-            CacherRequest::GetStatus => {
-                let mut map = serializer.serialize_map(Some(1))?;
-                map.serialize_entry("GetStatus", &())?;
-                map.end()
-            }
+            CacherRequest::GetStatus => serializer.serialize_str("GetStatus"),
             CacherRequest::GetLogsByRange(request) => {
                 let mut map = serializer.serialize_map(Some(1))?;
                 map.serialize_entry("GetLogsByRange", request)?;
                 map.end()
             }
-            CacherRequest::StartProviding => {
-                let mut map = serializer.serialize_map(Some(1))?;
-                map.serialize_entry("StartProviding", &())?;
-                map.end()
-            }
-            CacherRequest::StopProviding => {
-                let mut map = serializer.serialize_map(Some(1))?;
-                map.serialize_entry("StopProviding", &())?;
-                map.end()
-            }
+            CacherRequest::StartProviding => serializer.serialize_str("StartProviding"),
+            CacherRequest::StopProviding => serializer.serialize_str("StopProviding"),
             CacherRequest::SetNodes(nodes) => {
                 let mut map = serializer.serialize_map(Some(1))?;
                 map.serialize_entry("SetNodes", nodes)?;
@@ -1591,8 +1575,32 @@ impl<'de> Deserialize<'de> for CacherRequest {
             type Value = CacherRequest;
 
             fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                formatter
-                    .write_str("a map with a single key representing the CacherRequest variant")
+                formatter.write_str("a string for unit variants or a map for other variants")
+            }
+
+            fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
+            where
+                E: de::Error,
+            {
+                match value {
+                    "GetManifest" => Ok(CacherRequest::GetManifest),
+                    "GetStatus" => Ok(CacherRequest::GetStatus),
+                    "StartProviding" => Ok(CacherRequest::StartProviding),
+                    "StopProviding" => Ok(CacherRequest::StopProviding),
+                    _ => Err(de::Error::unknown_variant(
+                        value,
+                        &[
+                            "GetManifest",
+                            "GetLogCacheContent",
+                            "GetStatus",
+                            "GetLogsByRange",
+                            "StartProviding",
+                            "StopProviding",
+                            "SetNodes",
+                            "Reset",
+                        ],
+                    )),
+                }
             }
 
             fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
@@ -1603,19 +1611,20 @@ impl<'de> Deserialize<'de> for CacherRequest {
                     .next_entry::<String, serde_json::Value>()?
                     .ok_or_else(|| de::Error::invalid_length(0, &self))?;
 
+                // Ensure there are no extra entries
+                if map.next_entry::<String, serde_json::Value>()?.is_some() {
+                    return Err(de::Error::custom("unexpected extra entries in map"));
+                }
+
                 match variant.as_str() {
-                    "GetManifest" => Ok(CacherRequest::GetManifest),
                     "GetLogCacheContent" => {
                         let path = serde_json::from_value(value).map_err(de::Error::custom)?;
                         Ok(CacherRequest::GetLogCacheContent(path))
                     }
-                    "GetStatus" => Ok(CacherRequest::GetStatus),
                     "GetLogsByRange" => {
                         let request = serde_json::from_value(value).map_err(de::Error::custom)?;
                         Ok(CacherRequest::GetLogsByRange(request))
                     }
-                    "StartProviding" => Ok(CacherRequest::StartProviding),
-                    "StopProviding" => Ok(CacherRequest::StopProviding),
                     "SetNodes" => {
                         let nodes = serde_json::from_value(value).map_err(de::Error::custom)?;
                         Ok(CacherRequest::SetNodes(nodes))
@@ -1641,7 +1650,7 @@ impl<'de> Deserialize<'de> for CacherRequest {
             }
         }
 
-        deserializer.deserialize_map(CacherRequestVisitor)
+        deserializer.deserialize_any(CacherRequestVisitor)
     }
 }
 
@@ -1681,16 +1690,8 @@ impl Serialize for CacherResponse {
                 map.serialize_entry("StopProviding", result)?;
                 map.end()
             }
-            CacherResponse::Rejected => {
-                let mut map = serializer.serialize_map(Some(1))?;
-                map.serialize_entry("Rejected", &())?;
-                map.end()
-            }
-            CacherResponse::IsStarting => {
-                let mut map = serializer.serialize_map(Some(1))?;
-                map.serialize_entry("IsStarting", &())?;
-                map.end()
-            }
+            CacherResponse::Rejected => serializer.serialize_str("Rejected"),
+            CacherResponse::IsStarting => serializer.serialize_str("IsStarting"),
             CacherResponse::SetNodes(result) => {
                 let mut map = serializer.serialize_map(Some(1))?;
                 map.serialize_entry("SetNodes", result)?;
@@ -1716,8 +1717,32 @@ impl<'de> Deserialize<'de> for CacherResponse {
             type Value = CacherResponse;
 
             fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                formatter
-                    .write_str("a map with a single key representing the CacherResponse variant")
+                formatter.write_str("a string for unit variants or a map for other variants")
+            }
+
+            fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
+            where
+                E: de::Error,
+            {
+                match value {
+                    "Rejected" => Ok(CacherResponse::Rejected),
+                    "IsStarting" => Ok(CacherResponse::IsStarting),
+                    _ => Err(de::Error::unknown_variant(
+                        value,
+                        &[
+                            "GetManifest",
+                            "GetLogCacheContent",
+                            "GetStatus",
+                            "GetLogsByRange",
+                            "StartProviding",
+                            "StopProviding",
+                            "Rejected",
+                            "IsStarting",
+                            "SetNodes",
+                            "Reset",
+                        ],
+                    )),
+                }
             }
 
             fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
@@ -1728,6 +1753,11 @@ impl<'de> Deserialize<'de> for CacherResponse {
                     .next_entry::<String, serde_json::Value>()?
                     .ok_or_else(|| de::Error::invalid_length(0, &self))?;
 
+                // Ensure there are no extra entries
+                if map.next_entry::<String, serde_json::Value>()?.is_some() {
+                    return Err(de::Error::custom("unexpected extra entries in map"));
+                }
+
                 match variant.as_str() {
                     "GetManifest" => {
                         let manifest = serde_json::from_value(value).map_err(de::Error::custom)?;
@@ -1753,8 +1783,6 @@ impl<'de> Deserialize<'de> for CacherResponse {
                         let result = serde_json::from_value(value).map_err(de::Error::custom)?;
                         Ok(CacherResponse::StopProviding(result))
                     }
-                    "Rejected" => Ok(CacherResponse::Rejected),
-                    "IsStarting" => Ok(CacherResponse::IsStarting),
                     "SetNodes" => {
                         let result = serde_json::from_value(value).map_err(de::Error::custom)?;
                         Ok(CacherResponse::SetNodes(result))
@@ -1782,7 +1810,7 @@ impl<'de> Deserialize<'de> for CacherResponse {
             }
         }
 
-        deserializer.deserialize_map(CacherResponseVisitor)
+        deserializer.deserialize_any(CacherResponseVisitor)
     }
 }
 

src/hypermap.rs

@@ -13,6 +13,14 @@
 //! for applications that want to maximize composability and introspectability.
 //! For blobs, we recommend bincode to serialize and deserialize to bytes.
 //!
+//! `process_lib` v`2.x.y` uses [`wit-bindgen`](https://github.com/bytecodealliance/wit-bindgen) v`0.42.1`.
+//! Processes depending on `process_lib` must also use that version.
+//!
+//! `process_lib` version | `wit-bindgen` version
+//! --------------------- | ---------------------
+//! `2.x.y`               | `0.42.1`
+//! `1.x.y`               | `0.36.0`
+//!
 pub use crate::hyperware::process::standard::*;
 use serde_json::Value;