Merge pull request #30 from uqbar-dao/dr/denectar-where-possible

sys:nectar -> distro:sys, removal of 'Nectar' from comments

Author: dr-frmr

.gitmodules

@@ -1,4 +1,4 @@
-[submodule "nectar-wit"]
-	path = nectar-wit
-	url = https://github.com/uqbar-dao/nectar-wit.git
+[submodule "kinode-wit"]
+	path = kinode-wit
+	url = https://github.com/uqbar-dao/kinode-wit.git
 	branch = master

Cargo.lock

@@ -1,5 +1,5 @@
 [package]
-name = "nectar_process_lib"
+name = "kinode_process_lib"
 version = "0.5.0"
 edition = "2021"
 

Cargo.toml

@@ -1,10 +1,10 @@
 # process_lib
 
-Library of functions for more ergonomic Nectar process development.
+Library of functions for more ergonomic kinode process development.
 
 To develop/build:
 ```
-git submodule add https://github.com/uqbar-dao/nectar-wit.git
+git submodule add https://github.com/uqbar-dao/kinode-wit.git
 ```
 
 Docs: (TODO link)

README.md

@@ -3,9 +3,9 @@ use serde::{Deserialize, Serialize};
 use std::hash::{Hash, Hasher};
 
 /// Address is defined in the wit bindings, but constructors and methods here.
-/// An `Address` is a combination of an Nectar node ID and a [`ProcessId`]. It is
+/// An `Address` is a combination of a node ID (string) and a [`ProcessId`]. It is
 /// used in the Request/Response pattern to indicate which process on a given node
-/// in the Nectar Network to direct the message to. The formatting structure for
+/// in the network to direct the message to. The formatting structure for
 /// an Address is `node@process_name:package_name:publisher_node`
 impl Address {
     /// Create a new `Address`. Takes a node ID and a process ID.
@@ -33,8 +33,8 @@ impl Address {
     }
     /// Read the publisher node ID from an `Address`. Note that `Address`
     /// segments are not parsed for validity, and a node ID stored here is
-    /// not guaranteed to be a valid ID in the Nectar name system, or be connected
-    /// to an Nectar identity at all.
+    /// not guaranteed to be a valid ID in the name system, or be connected
+    /// to an identity at all.
     pub fn publisher(&self) -> &str {
         &self.process.publisher_node
     }

nectar-wit renamed to kinode-wit

@@ -3,7 +3,7 @@ use serde::{Deserialize, Serialize};
 use std::hash::{Hash, Hasher};
 
 /// Capability is defined in the wit bindings, but constructors and methods here.
-/// A `Capability` is a combination of an Nectar Address and a set of Params (a serialized
+/// A `Capability` is a combination of an Address and a set of Params (a serialized
 /// json string). Capabilities are attached to messages to either share that capability
 /// with the receiving process, or to prove that a process has authority to perform a
 /// certain action.

src/address.rs

@@ -6,7 +6,7 @@ pub use ethers_core::types::{
 };
 use serde::{Deserialize, Serialize};
 
-/// The Request type that can be made to eth:sys:nectar. Currently primitive, this
+/// The Request type that can be made to eth:distro:sys. Currently primitive, this
 /// enum will expand to support more actions in the future.
 ///
 /// Will be serialized and deserialized using `serde_json::to_vec` and `serde_json::from_slice`.
@@ -54,7 +54,7 @@ impl SubscribeLogsRequest {
     pub fn new(id: u64) -> Self {
         let request = uqRequest::new().target(uqAddress::new(
             "our",
-            ProcessId::new(Some("eth"), "sys", "nectar"),
+            ProcessId::new(Some("eth"), "distro", "sys"),
         ));
 
         SubscribeLogsRequest {

src/capability.rs

@@ -15,7 +15,7 @@ use thiserror::Error;
 //
 
 /// HTTP Request type that can be shared over WASM boundary to apps.
-/// This is the one you receive from the `http_server:sys:nectar` service.
+/// This is the one you receive from the `http_server:distro:sys` service.
 #[derive(Debug, Serialize, Deserialize)]
 pub enum HttpServerRequest {
     Http(IncomingHttpRequest),
@@ -57,7 +57,7 @@ pub struct HttpResponse {
     // BODY is stored in the lazy_load_blob, as bytes
 }
 
-/// Request type sent to `http_server:sys:nectar` in order to configure it.
+/// Request type sent to `http_server:distro:sys` in order to configure it.
 /// You can also send [`type@HttpServerAction::WebSocketPush`], which
 /// allows you to push messages across an existing open WebSocket connection.
 ///
@@ -210,7 +210,7 @@ impl IncomingHttpRequest {
 }
 
 /// Request type that can be shared over WASM boundary to apps.
-/// This is the one you send to the `http_client:sys:nectar` service.
+/// This is the one you send to the `http_client:distro:sys` service.
 #[derive(Debug, Serialize, Deserialize)]
 pub enum HttpClientAction {
     Http(OutgoingHttpRequest),
@@ -229,7 +229,7 @@ pub enum HttpClientAction {
 }
 
 /// HTTP Request type that can be shared over WASM boundary to apps.
-/// This is the one you send to the `http_client:sys:nectar` service.
+/// This is the one you send to the `http_client:distro:sys` service.
 #[derive(Debug, Serialize, Deserialize)]
 pub struct OutgoingHttpRequest {
     pub method: String,          // must parse to http::Method
@@ -241,7 +241,7 @@ pub struct OutgoingHttpRequest {
 }
 
 /// WebSocket Client Request type that can be shared over WASM boundary to apps.
-/// This comes from an open websocket client connection in the `http_client:sys:nectar` service.
+/// This comes from an open websocket client connection in the `http_client:distro:sys` service.
 #[derive(Debug, Serialize, Deserialize)]
 pub enum HttpClientRequest {
     WebSocketPush {
@@ -254,7 +254,7 @@ pub enum HttpClientRequest {
 }
 
 /// HTTP Client Response type that can be shared over WASM boundary to apps.
-/// This is the one you receive from the `http_client:sys:nectar` service.
+/// This is the one you receive from the `http_client:distro:sys` service.
 #[derive(Debug, Serialize, Deserialize)]
 pub enum HttpClientResponse {
     Http(HttpResponse),
@@ -292,7 +292,7 @@ where
     T: Into<String>,
 {
     let res = uqRequest::new()
-        .target(("our", "http_server", "sys", "nectar"))
+        .target(("our", "http_server", "distro", "sys"))
         .body(serde_json::to_vec(&HttpServerAction::Bind {
             path: path.into(),
             authenticated,
@@ -322,14 +322,14 @@ where
     T: Into<String>,
 {
     let res = uqRequest::new()
-        .target(("our", "http_server", "sys", "nectar"))
+        .target(("our", "http_server", "distro", "sys"))
         .body(serde_json::to_vec(&HttpServerAction::Bind {
             path: path.into(),
             authenticated,
             local_only,
             cache: true,
         })?)
-        .blob(crate::nectar::process::standard::LazyLoadBlob {
+        .blob(crate::kinode::process::standard::LazyLoadBlob {
             mime: content_type,
             bytes: content,
         })
@@ -350,7 +350,7 @@ where
     T: Into<String>,
 {
     let res = uqRequest::new()
-        .target(("our", "http_server", "sys", "nectar"))
+        .target(("our", "http_server", "distro", "sys"))
         .body(serde_json::to_vec(&HttpServerAction::WebSocketBind {
             path: path.into(),
             authenticated,
@@ -391,7 +391,7 @@ pub fn send_request(
     body: Vec<u8>,
 ) -> anyhow::Result<()> {
     let req = uqRequest::new()
-        .target(("our", "http_client", "sys", "nectar"))
+        .target(("our", "http_client", "distro", "sys"))
         .body(serde_json::to_vec(&HttpClientAction::Http(
             OutgoingHttpRequest {
                 method: method.to_string(),
@@ -417,7 +417,7 @@ pub fn send_request_await_response(
     body: Vec<u8>,
 ) -> std::result::Result<HttpClientResponse, HttpClientError> {
     let res = uqRequest::new()
-        .target(("our", "http_client", "sys", "nectar"))
+        .target(("our", "http_client", "distro", "sys"))
         .body(
             serde_json::to_vec(&HttpClientAction::Http(OutgoingHttpRequest {
                 method: method.to_string(),
@@ -463,7 +463,7 @@ pub fn get_mime_type(filename: &str) -> String {
 // Serve index.html
 pub fn serve_index_html(our: &Address, directory: &str) -> anyhow::Result<(), anyhow::Error> {
     let _ = uqRequest::new()
-        .target("our@vfs:sys:nectar".parse::<Address>()?)
+        .target("our@vfs:distro:sys".parse::<Address>()?)
         .body(serde_json::to_vec(&VfsRequest {
             path: format!("/{}/pkg/{}/index.html", our.package_id(), directory),
             action: VfsAction::Read,
@@ -499,7 +499,7 @@ pub fn serve_ui(our: &Address, directory: &str) -> anyhow::Result<(), anyhow::Er
 
     while let Some(path) = queue.pop_front() {
         let directory_response = uqRequest::new()
-            .target("our@vfs:sys:nectar".parse::<Address>()?)
+            .target("our@vfs:distro:sys".parse::<Address>()?)
             .body(serde_json::to_vec(&VfsRequest {
                 path,
                 action: VfsAction::ReadDir,
@@ -526,7 +526,7 @@ pub fn serve_ui(our: &Address, directory: &str) -> anyhow::Result<(), anyhow::Er
                             }
 
                             let _ = uqRequest::new()
-                                .target("our@vfs:sys:nectar".parse::<Address>()?)
+                                .target("our@vfs:distro:sys".parse::<Address>()?)
                                 .body(serde_json::to_vec(&VfsRequest {
                                     path: entry.path.clone(),
                                     action: VfsAction::Read,
@@ -581,7 +581,7 @@ pub fn handle_ui_asset_request(
     let target_path = format!("{}/{}", directory, after_process.trim_start_matches('/'));
 
     let _ = uqRequest::new()
-        .target("our@vfs:sys:nectar".parse::<Address>()?)
+        .target("our@vfs:distro:sys".parse::<Address>()?)
         .body(serde_json::to_vec(&VfsRequest {
             path: format!("{}/pkg/{}", our.package_id(), target_path),
             action: VfsAction::Read,
@@ -617,7 +617,7 @@ pub fn send_ws_push(
     uqRequest::new()
         .target(Address::new(
             node,
-            "http_server:sys:nectar".parse::<ProcessId>().unwrap(),
+            "http_server:distro:sys".parse::<ProcessId>().unwrap(),
         ))
         .body(
             serde_json::json!(HttpServerRequest::WebSocketPush {
@@ -643,7 +643,7 @@ pub fn open_ws_connection(
     uqRequest::new()
         .target(Address::new(
             node,
-            ProcessId::from_str("http_client:sys:nectar").unwrap(),
+            ProcessId::from_str("http_client:distro:sys").unwrap(),
         ))
         .body(
             serde_json::json!(HttpClientAction::WebSocketOpen {
@@ -669,7 +669,7 @@ pub fn open_ws_connection_and_await(
     uqRequest::new()
         .target(Address::new(
             node,
-            ProcessId::from_str("http_client:sys:nectar").unwrap(),
+            ProcessId::from_str("http_client:distro:sys").unwrap(),
         ))
         .body(
             serde_json::json!(HttpClientAction::WebSocketOpen {
@@ -693,7 +693,7 @@ pub fn send_ws_client_push(
     uqRequest::new()
         .target(Address::new(
             node,
-            ProcessId::from_str("http_client:sys:nectar").unwrap(),
+            ProcessId::from_str("http_client:distro:sys").unwrap(),
         ))
         .body(
             serde_json::json!(HttpClientAction::WebSocketPush {
@@ -712,7 +712,7 @@ pub fn close_ws_connection(node: String, channel_id: u32) -> anyhow::Result<()>
     uqRequest::new()
         .target(Address::new(
             node,
-            ProcessId::from_str("http_client:sys:nectar").unwrap(),
+            ProcessId::from_str("http_client:distro:sys").unwrap(),
         ))
         .body(
             serde_json::json!(HttpClientAction::WebSocketClose { channel_id })
@@ -732,7 +732,7 @@ pub fn close_ws_connection_and_await(
     uqRequest::new()
         .target(Address::new(
             node,
-            ProcessId::from_str("http_client:sys:nectar").unwrap(),
+            ProcessId::from_str("http_client:distro:sys").unwrap(),
         ))
         .body(
             serde_json::json!(HttpClientAction::WebSocketClose { channel_id })

src/eth.rs

@@ -1,12 +1,12 @@
-use crate::nectar::process::standard as wit;
+use crate::kinode::process::standard as wit;
 use crate::{Address, ProcessId};
 use serde::{Deserialize, Serialize};
 use std::collections::HashSet;
 
 //
 // process-facing kernel types, used for process
 // management and message-passing
-// matches types in nectar.wit
+// matches types in kinode.wit
 //
 
 pub type Context = Vec<u8>;