Support update builds.

2026-06-25 18:25:02 -04:00
parent 606832f505
commit d341228f5b
8 changed files with 481 additions and 224 deletions
--- a/src/nix_util/running_update.rs
+++ b/src/nix_util/running_update.rs
@@ -0,0 +1,138 @@
+use tokio::process::Child;
+use tracing::error;
+
+use crate::Result;
+use crate::nix_util::NixOutputStream;
+use crate::nix_util::nix_output_stream::NixAction;
+use crate::nix_util::output_stream::OutputStream;
+
+use super::activity_tree::ActivityId;
+use super::activity_tree::ActivityTreeEntry;
+use super::activity_tree_stream::ActivityTreeStream;
+use super::nix_output_stream::ActivityResultMessage;
+use super::nix_output_stream::NixMessage;
+use super::transparent_iter::TransparentIter;
+
+pub(crate) struct RunningUpdate {
+    activity_tree: ActivityTreeStream,
+}
+
+impl RunningUpdate {
+    pub(crate) fn new() -> Result<Self> {
+        Ok(RunningUpdate {
+            activity_tree: ActivityTreeStream::new(),
+        })
+    }
+
+    pub(crate) async fn run_to_completion(&mut self, mut child: Child) -> Result<()> {
+        let output_stream = OutputStream::from_child(&mut child)?;
+        let mut nix_output_stream: NixOutputStream<OutputStream> =
+            NixOutputStream::new(output_stream);
+
+        let exit_status_handle = tokio::spawn(async move {
+            let status = child
+                .wait()
+                .await
+                .expect("nixos-rebuild encountered an error");
+            status
+        });
+
+        while let Some(message) = nix_output_stream.next().await? {
+            self.handle_message(message)?;
+        }
+
+        let exit_status = exit_status_handle.await?;
+        println!("nix build status was: {}", exit_status);
+
+        Ok(())
+    }
+
+    pub(crate) fn handle_message(&mut self, message: NixMessage) -> Result<()> {
+        self.activity_tree.handle_message(&message)?;
+
+        let message = match message {
+            NixMessage::ParseFailure(line) => {
+                error!("FAIL PARSE: {line}");
+                return Ok(());
+            }
+            NixMessage::Generic(_value, line) => {
+                error!("GENERIC PARSE: {line}");
+                return Ok(());
+            }
+            NixMessage::Action(nix_action) => nix_action,
+        };
+        match message {
+            NixAction::Msg(msg_message) => {
+                // if msg_message.level > 0 && msg_message.level < 5 {
+                //     eprintln!("LOG MESSAGE {}: {}", msg_message.level, msg_message.msg);
+                // }
+            }
+            NixAction::Start(activity_start_message) => {
+                println!("START: {}", serde_json::to_string(&activity_start_message)?);
+                self.print_current_status();
+            }
+            NixAction::Stop(stop_message) => {
+                println!("STOP: {}", serde_json::to_string(&stop_message)?);
+                self.print_current_status();
+            }
+            NixAction::Result(activity_result_message) => {
+                match activity_result_message {
+                    ActivityResultMessage::FileLinked(_activity_result_file_linked) => {}
+                    ActivityResultMessage::BuildLogLine(_activity_result_build_log_line) => {}
+                    ActivityResultMessage::UntrustedPath(_activity_result_untrusted_path) => {}
+                    ActivityResultMessage::CorruptedPath(_activity_result_corrupted_path) => {}
+                    ActivityResultMessage::SetPhase(_activity_result_set_phase) => {}
+                    ActivityResultMessage::Progress(activity_result_progress) => {
+                        // if activity_result_progress.expected != 0 {
+                        println!(
+                            "PROGRESS: {}",
+                            serde_json::to_string(&activity_result_progress)?
+                        );
+                        // }
+                        self.maybe_print_current_status();
+                    }
+                    ActivityResultMessage::SetExpected(activity_result_set_expected) => {
+                        // if activity_result_set_expected.expected != 0 {
+                        println!(
+                            "EXPECTED: {}",
+                            serde_json::to_string(&activity_result_set_expected)?
+                        );
+                        // }
+                        self.maybe_print_current_status();
+                    }
+                    ActivityResultMessage::PostBuildLogLine(
+                        _activity_result_post_build_log_line,
+                    ) => {}
+                    ActivityResultMessage::FetchStatus(_activity_result_fetch_status) => {}
+                };
+            }
+        };
+        Ok(())
+    }
+
+    fn maybe_print_current_status(&mut self) -> () {}
+
+    fn print_current_status(&mut self) -> () {
+        let nodes = self.get_children_in_order(self.activity_tree.get_tree().get_root_id());
+        println!("\n\n\nvvvvvv\n\n");
+        for n in nodes {
+            let activity = n.get_activity();
+            // if activity.is_active() {
+            println!("{:?}", activity.display_name());
+            // }
+        }
+        println!("\n\n\n^^^^^^\n\n");
+    }
+
+    fn get_children_in_order(
+        &self,
+        parent_id: ActivityId,
+    ) -> impl Iterator<Item = &ActivityTreeEntry> {
+        let parent = self.activity_tree.get_tree().get(&parent_id);
+        parent
+            .get_child_ids()
+            .iter()
+            .map(|child_id| self.activity_tree.get_tree().get(child_id))
+            .flat_map(|child| TransparentIter::new(self.activity_tree.get_tree(), child))
+    }
+}