Merge pull request #79 from kinode-dao/dr/kernel-command-response

add KernelPrintResponse, ProcessMap, and update PersistedProcess to match runtime

Author: dr-frmr

src/kernel_types.rs

@@ -47,6 +47,18 @@ pub struct Capability {
     pub params: String, // JSON-string
 }
 
+impl std::fmt::Display for Capability {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{}({})",
+            self.issuer,
+            serde_json::from_str::<serde_json::Value>(&self.params)
+                .unwrap_or(serde_json::json!("invalid JSON in capability"))
+        )
+    }
+}
+
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct SendError {
     pub kind: SendErrorKind,
@@ -139,16 +151,27 @@ pub enum KernelResponse {
     StartedProcess,
     RunProcessError,
     KilledProcess(ProcessId),
+    Debug(KernelPrintResponse),
 }
 
+#[derive(Debug, Serialize, Deserialize)]
+pub enum KernelPrintResponse {
+    ProcessMap(ProcessMap),
+    Process(Option<PersistedProcess>),
+    HasCap(Option<bool>),
+}
+
+pub type ProcessMap = HashMap<ProcessId, PersistedProcess>;
+
+// NOTE: this is different from the runtime representation of a process
+// in that the capabilities are stored as a HashSet instead of a HashMap.
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct PersistedProcess {
     pub wasm_bytes_handle: String,
-    // pub drive: String,
-    // pub full_path: String,
+    pub wit_version: Option<u32>,
     pub on_exit: OnExit,
     pub capabilities: HashSet<Capability>,
-    pub public: bool, // marks if a process allows messages from any process
+    pub public: bool,
 }
 
 #[derive(Serialize, Deserialize, Debug)]

src/lib.rs

@@ -19,6 +19,7 @@ use serde_json::Value;
 
 wit_bindgen::generate!({
     path: "kinode-wit",
+    generate_unused_types: true,
     world: "lib",
 });
 

src/types/address.rs

@@ -1,4 +1,4 @@
-pub use crate::{Address, PackageId, ProcessId};
+pub use crate::{Address, ProcessId};
 use serde::{Deserialize, Serialize};
 use std::hash::{Hash, Hasher};
 
@@ -39,8 +39,8 @@ impl Address {
         &self.process.publisher_node
     }
     /// Read the package_id (package + publisher) from an `Address`.
-    pub fn package_id(&self) -> PackageId {
-        PackageId::new(self.package(), self.publisher())
+    pub fn package_id(&self) -> crate::PackageId {
+        crate::PackageId::new(self.package(), self.publisher())
     }
 }
 

src/types/package_id.rs

@@ -1,15 +1,9 @@
+pub use crate::PackageId;
 use crate::ProcessIdParseError;
 use serde::{Deserialize, Serialize};
-use std::hash::Hash;
-
-/// PackageId is like a ProcessId, but for a package. Only contains the name
-/// of the package and the name of the publisher.
-#[derive(Hash, Eq, PartialEq, Debug, Clone, Serialize, Deserialize)]
-pub struct PackageId {
-    package_name: String,
-    publisher_node: String,
-}
 
+/// `PackageId` is defined in the wit bindings, but constructors and methods
+/// are defined here. A `PackageId` contains a package name and a publisher node ID.
 impl PackageId {
     /// Create a new `PackageId`.
     pub fn new(package_name: &str, publisher_node: &str) -> Self {
@@ -31,6 +25,25 @@ impl PackageId {
     }
 }
 
+impl Serialize for PackageId {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::ser::Serializer,
+    {
+        format!("{}", self).serialize(serializer)
+    }
+}
+
+impl<'a> Deserialize<'a> for PackageId {
+    fn deserialize<D>(deserializer: D) -> Result<PackageId, D::Error>
+    where
+        D: serde::de::Deserializer<'a>,
+    {
+        let s = String::deserialize(deserializer)?;
+        s.parse().map_err(serde::de::Error::custom)
+    }
+}
+
 impl std::str::FromStr for PackageId {
     type Err = ProcessIdParseError;
     /// Attempt to parse a `PackageId` from a string. The string must
@@ -64,8 +77,29 @@ impl std::str::FromStr for PackageId {
     }
 }
 
+impl std::hash::Hash for PackageId {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.package_name.hash(state);
+        self.publisher_node.hash(state);
+    }
+}
+
 impl std::fmt::Display for PackageId {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(f, "{}:{}", self.package_name, self.publisher_node)
     }
 }
+
+impl From<(&str, &str)> for PackageId {
+    fn from(input: (&str, &str)) -> Self {
+        PackageId::new(input.0, input.1)
+    }
+}
+
+impl std::cmp::Eq for PackageId {}
+
+impl PartialEq for PackageId {
+    fn eq(&self, other: &Self) -> bool {
+        self.package_name == other.package_name && self.publisher_node == other.publisher_node
+    }
+}