Merge branch 'main' into hf/hotfix-kit-s

kinode/packages/app_store/app_store/src/lib.rs

@@ -71,7 +71,6 @@ pub enum Resp {
 }
 
 fn fetch_logs(eth_provider: &eth::Provider, filter: &eth::Filter) -> Vec<eth::Log> {
-    #[cfg(not(feature = "simulation-mode"))]
     loop {
         match eth_provider.get_logs(filter) {
             Ok(res) => return res,
@@ -88,7 +87,6 @@ fn fetch_logs(eth_provider: &eth::Provider, filter: &eth::Filter) -> Vec<eth::Lo
 
 #[allow(unused_variables)]
 fn subscribe_to_logs(eth_provider: &eth::Provider, filter: eth::Filter) {
-    #[cfg(not(feature = "simulation-mode"))]
     loop {
         match eth_provider.subscribe(1, filter.clone()) {
             Ok(()) => break,
@@ -99,7 +97,6 @@ fn subscribe_to_logs(eth_provider: &eth::Provider, filter: eth::Filter) {
             }
         }
     }
-    #[cfg(not(feature = "simulation-mode"))]
     println!("subscribed to logs successfully");
 }
 

kinode/packages/kns_indexer/kns_indexer/src/lib.rs

@@ -99,7 +99,6 @@ sol! {
 }
 
 fn subscribe_to_logs(eth_provider: &eth::Provider, from_block: u64, filter: eth::Filter) {
-    #[cfg(not(feature = "simulation-mode"))]
     loop {
         match eth_provider.subscribe(1, filter.clone().from_block(from_block)) {
             Ok(()) => break,
@@ -110,7 +109,6 @@ fn subscribe_to_logs(eth_provider: &eth::Provider, from_block: u64, filter: eth:
             }
         }
     }
-    #[cfg(not(feature = "simulation-mode"))]
     println!("subscribed to logs successfully");
 }
 

kinode/src/kernel/mod.rs

@@ -468,12 +468,6 @@ async fn handle_kernel_request(
                     return;
                 }
             };
-            let _ = send_to_terminal
-                .send(t::Printout {
-                    verbosity: 2,
-                    content: format!("killing process {process_id}"),
-                })
-                .await;
             process_handle.abort();
             process_map.remove(&process_id);
             caps_oracle
@@ -484,6 +478,12 @@ async fn handle_kernel_request(
                 .await
                 .expect("event loop: fatal: sender died");
             if request.expects_response.is_none() {
+                let _ = send_to_terminal
+                    .send(t::Printout {
+                        verbosity: 2,
+                        content: format!("killing process {process_id}"),
+                    })
+                    .await;
                 return;
             }
             let _ = send_to_terminal
@@ -716,18 +716,19 @@ pub async fn kernel(
     let mut is_debug: bool = false;
     let mut reboot_processes: Vec<(t::ProcessId, StartProcessMetadata, Vec<u8>)> = vec![];
 
+    // filter out OnExit::None processes from process_map
+    process_map.retain(|_, persisted| !persisted.on_exit.is_none());
+
     for (process_id, persisted) in &process_map {
         // runtime extensions will have a bytes_handle of "", because they have no
         // WASM code saved in filesystem.
-        if persisted.on_exit.is_restart() && !persisted.wasm_bytes_handle.is_empty() {
-            // read wasm bytes directly from vfs
-            // start process.
-            let wasm_bytes = match tokio::fs::read(format!(
-                "{}/{}",
-                vfs_path, persisted.wasm_bytes_handle
-            ))
-            .await
-            {
+        if persisted.wasm_bytes_handle.is_empty() {
+            continue;
+        }
+        // read wasm bytes directly from vfs
+        // start process.
+        let wasm_bytes =
+            match tokio::fs::read(format!("{}/{}", vfs_path, persisted.wasm_bytes_handle)).await {
                 Ok(bytes) => bytes,
                 Err(e) => {
                     let _ = send_to_terminal
@@ -742,20 +743,19 @@ pub async fn kernel(
                     continue;
                 }
             };
-            reboot_processes.push((
-                process_id.clone(),
-                StartProcessMetadata {
-                    source: t::Address {
-                        node: our.name.clone(),
-                        process: KERNEL_PROCESS_ID.clone(),
-                    },
-                    process_id: process_id.clone(),
-                    persisted: persisted.clone(),
-                    reboot: true,
+        reboot_processes.push((
+            process_id.clone(),
+            StartProcessMetadata {
+                source: t::Address {
+                    node: our.name.clone(),
+                    process: KERNEL_PROCESS_ID.clone(),
                 },
-                wasm_bytes,
-            ));
-        }
+                process_id: process_id.clone(),
+                persisted: persisted.clone(),
+                reboot: true,
+            },
+            wasm_bytes,
+        ));
         if let t::OnExit::Requests(requests) = &persisted.on_exit {
             // if a persisted process had on-death-requests, we should perform them now
             // even in death, a process can only message processes it has capabilities for

kinode/src/kernel/process.rs

@@ -646,6 +646,9 @@ pub async fn make_process_loop(
     // the process has completed, time to perform cleanup
     //
 
+    // update metadata to what was mutated by process in store
+    let metadata = store.data().process.metadata.to_owned();
+
     let our_kernel = t::Address {
         node: metadata.our.node.clone(),
         process: KERNEL_PROCESS_ID.clone(),

lib/src/core.rs

@@ -483,6 +483,14 @@ impl OnExit {
         }
     }
 
+    pub fn is_none(&self) -> bool {
+        match self {
+            OnExit::None => true,
+            OnExit::Restart => false,
+            OnExit::Requests(_) => false,
+        }
+    }
+
     pub fn en_wit(&self) -> wit::OnExit {
         match self {
             OnExit::None => wit::OnExit::None,