nix_builder/src/nix_util/running_update.rs

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))
    }
}