275 lines
13 KiB
Rust
275 lines
13 KiB
Rust
use crate::Result;
|
|
|
|
use super::activity::Activity;
|
|
use super::activity::ActivityBuild;
|
|
use super::activity::ActivityBuildWaiting;
|
|
use super::activity::ActivityBuilds;
|
|
use super::activity::ActivityCopyPath;
|
|
use super::activity::ActivityCopyPaths;
|
|
use super::activity::ActivityFetchTree;
|
|
use super::activity::ActivityFileTransfer;
|
|
use super::activity::ActivityOptimizeStore;
|
|
use super::activity::ActivityPostBuildHook;
|
|
use super::activity::ActivityQueryPathInfo;
|
|
use super::activity::ActivityRealize;
|
|
use super::activity::ActivityState;
|
|
use super::activity::ActivitySubstitute;
|
|
use super::activity::ActivityUnknown;
|
|
use super::activity::ActivityVerifyPaths;
|
|
use super::activity_tree::ActivityTree;
|
|
use super::nix_output_stream::ActivityResultMessage;
|
|
use super::nix_output_stream::ActivityStartMessage;
|
|
use super::nix_output_stream::NixAction;
|
|
use super::nix_output_stream::NixMessage;
|
|
|
|
pub(crate) struct ActivityTreeStream {
|
|
activity_tree: ActivityTree,
|
|
}
|
|
|
|
impl ActivityTreeStream {
|
|
pub(crate) fn new() -> ActivityTreeStream {
|
|
ActivityTreeStream {
|
|
activity_tree: ActivityTree::new(),
|
|
}
|
|
}
|
|
|
|
pub(crate) fn get_tree(&self) -> &ActivityTree {
|
|
&self.activity_tree
|
|
}
|
|
|
|
pub(crate) fn get_tree_mut(&mut self) -> &mut ActivityTree {
|
|
&mut self.activity_tree
|
|
}
|
|
|
|
pub(crate) fn handle_message(&mut self, message: &NixMessage) -> Result<()> {
|
|
let message = match message {
|
|
NixMessage::ParseFailure(_) | NixMessage::Generic(_, _) => {
|
|
return Ok(());
|
|
}
|
|
NixMessage::Action(nix_action) => nix_action,
|
|
};
|
|
|
|
match message {
|
|
NixAction::Msg(_msg_message) => {
|
|
// if msg_message.msg.contains("nix log") {
|
|
// eprintln!("{}", msg_message.msg);
|
|
// }
|
|
// if msg_message.level == 0 {
|
|
// eprintln!("{}", msg_message.msg);
|
|
// }
|
|
}
|
|
NixAction::Start(activity_start_message) => {
|
|
match activity_start_message {
|
|
ActivityStartMessage::Unknown(activity_start_unknown) => {
|
|
self.activity_tree.add_activity(
|
|
activity_start_unknown.id,
|
|
activity_start_unknown.parent,
|
|
Activity::Unknown(ActivityUnknown {
|
|
state: ActivityState::default(),
|
|
text: activity_start_unknown.text.clone(),
|
|
}),
|
|
)?;
|
|
}
|
|
ActivityStartMessage::CopyPath(activity_start_copy_path) => {
|
|
self.activity_tree.add_activity(
|
|
activity_start_copy_path.id,
|
|
activity_start_copy_path.parent,
|
|
Activity::CopyPath(ActivityCopyPath {
|
|
state: ActivityState::default(),
|
|
missing_path: activity_start_copy_path.missing_path.clone(),
|
|
source: activity_start_copy_path.source.clone(),
|
|
destination: activity_start_copy_path.destination.clone(),
|
|
done: 0,
|
|
expected: 0,
|
|
}),
|
|
)?;
|
|
}
|
|
ActivityStartMessage::FileTransfer(activity_start_file_transfer) => {
|
|
self.activity_tree.add_activity(
|
|
activity_start_file_transfer.id,
|
|
activity_start_file_transfer.parent,
|
|
Activity::FileTransfer(ActivityFileTransfer {
|
|
state: ActivityState::default(),
|
|
url: activity_start_file_transfer.url.clone(),
|
|
done: 0,
|
|
expected: 0,
|
|
}),
|
|
)?;
|
|
}
|
|
ActivityStartMessage::Realize(activity_start_realize) => {
|
|
self.activity_tree.add_activity(
|
|
activity_start_realize.id,
|
|
activity_start_realize.parent,
|
|
Activity::Realize(ActivityRealize {
|
|
state: ActivityState::default(),
|
|
}),
|
|
)?;
|
|
}
|
|
ActivityStartMessage::CopyPaths(activity_start_copy_paths) => {
|
|
self.activity_tree.add_activity(
|
|
activity_start_copy_paths.id,
|
|
activity_start_copy_paths.parent,
|
|
Activity::CopyPaths(ActivityCopyPaths {
|
|
state: ActivityState::default(),
|
|
text: activity_start_copy_paths.text.clone(),
|
|
done: 0,
|
|
expected: 0,
|
|
running: 0,
|
|
failed: 0,
|
|
}),
|
|
)?;
|
|
}
|
|
ActivityStartMessage::Builds(activity_start_builds) => {
|
|
self.activity_tree.add_activity(
|
|
activity_start_builds.id,
|
|
activity_start_builds.parent,
|
|
Activity::Builds(ActivityBuilds {
|
|
state: ActivityState::default(),
|
|
done: 0,
|
|
expected: 0,
|
|
running: 0,
|
|
failed: 0,
|
|
}),
|
|
)?;
|
|
}
|
|
ActivityStartMessage::Build(activity_start_build) => {
|
|
self.activity_tree.add_activity(
|
|
activity_start_build.id,
|
|
activity_start_build.parent,
|
|
Activity::Build(ActivityBuild {
|
|
state: ActivityState::default(),
|
|
drv_path: activity_start_build.drv_path.clone(),
|
|
machine_name: if activity_start_build.machine_name.len() > 0 {
|
|
Some(activity_start_build.machine_name.clone())
|
|
} else {
|
|
None
|
|
},
|
|
phase: None,
|
|
}),
|
|
)?;
|
|
}
|
|
ActivityStartMessage::OptimizeStore(activity_start_optimize_store) => {
|
|
self.activity_tree.add_activity(
|
|
activity_start_optimize_store.id,
|
|
activity_start_optimize_store.parent,
|
|
Activity::OptimizeStore(ActivityOptimizeStore {
|
|
state: ActivityState::default(),
|
|
}),
|
|
)?;
|
|
}
|
|
ActivityStartMessage::VerifyPaths(activity_start_verify_paths) => {
|
|
self.activity_tree.add_activity(
|
|
activity_start_verify_paths.id,
|
|
activity_start_verify_paths.parent,
|
|
Activity::VerifyPaths(ActivityVerifyPaths {
|
|
state: ActivityState::default(),
|
|
}),
|
|
)?;
|
|
}
|
|
ActivityStartMessage::Substitute(activity_start_substitute) => {
|
|
self.activity_tree.add_activity(
|
|
activity_start_substitute.id,
|
|
activity_start_substitute.parent,
|
|
Activity::Substitute(ActivitySubstitute {
|
|
state: ActivityState::default(),
|
|
}),
|
|
)?;
|
|
}
|
|
ActivityStartMessage::QueryPathInfo(activity_start_query_path_info) => {
|
|
self.activity_tree.add_activity(
|
|
activity_start_query_path_info.id,
|
|
activity_start_query_path_info.parent,
|
|
Activity::QueryPathInfo(ActivityQueryPathInfo {
|
|
state: ActivityState::default(),
|
|
}),
|
|
)?;
|
|
}
|
|
ActivityStartMessage::PostBuildHook(activity_start_post_build_hook) => {
|
|
self.activity_tree.add_activity(
|
|
activity_start_post_build_hook.id,
|
|
activity_start_post_build_hook.parent,
|
|
Activity::PostBuildHook(ActivityPostBuildHook {
|
|
state: ActivityState::default(),
|
|
}),
|
|
)?;
|
|
}
|
|
ActivityStartMessage::BuildWaiting(activity_start_build_waiting) => {
|
|
self.activity_tree.add_activity(
|
|
activity_start_build_waiting.id,
|
|
0,
|
|
Activity::BuildWaiting(ActivityBuildWaiting {
|
|
state: ActivityState::default(),
|
|
text: activity_start_build_waiting.text.clone(),
|
|
drv_path: activity_start_build_waiting.drv_path.clone(),
|
|
path_resolved: activity_start_build_waiting.path_resolved.clone(),
|
|
}),
|
|
)?;
|
|
}
|
|
ActivityStartMessage::FetchTree(activity_start_fetch_tree) => {
|
|
self.activity_tree.add_activity(
|
|
activity_start_fetch_tree.id,
|
|
activity_start_fetch_tree.parent,
|
|
Activity::FetchTree(ActivityFetchTree {
|
|
state: ActivityState::default(),
|
|
}),
|
|
)?;
|
|
}
|
|
};
|
|
}
|
|
NixAction::Stop(stop_message) => {
|
|
let activity = self
|
|
.activity_tree
|
|
.get_activity_id(stop_message.id)
|
|
.map(|activity_id| self.activity_tree.get_mut(&activity_id))?;
|
|
activity.get_mut_activity().stop();
|
|
// println!("{}", serde_json::to_string(&message)?);
|
|
}
|
|
NixAction::Result(activity_result_message) => {
|
|
match activity_result_message {
|
|
ActivityResultMessage::FileLinked(_activity_result_file_linked) => {}
|
|
ActivityResultMessage::BuildLogLine(_activity_result_build_log_line) => {
|
|
// These are the output from the actual build (as opposed to the output from nix).
|
|
}
|
|
ActivityResultMessage::UntrustedPath(_activity_result_untrusted_path) => {}
|
|
ActivityResultMessage::CorruptedPath(_activity_result_corrupted_path) => {}
|
|
ActivityResultMessage::SetPhase(activity_result_set_phase) => {
|
|
let activity_id = self
|
|
.activity_tree
|
|
.get_activity_id(activity_result_set_phase.id)?;
|
|
let activity = self.activity_tree.get_mut(&activity_id);
|
|
activity
|
|
.get_mut_activity()
|
|
.set_phase(Some(activity_result_set_phase.phase.clone()));
|
|
}
|
|
ActivityResultMessage::Progress(activity_result_progress) => {
|
|
let activity_id = self
|
|
.activity_tree
|
|
.get_activity_id(activity_result_progress.id)?;
|
|
let activity = self.activity_tree.get_mut(&activity_id);
|
|
activity.get_mut_activity().set_progress(
|
|
activity_result_progress.done,
|
|
activity_result_progress.expected,
|
|
activity_result_progress.running,
|
|
activity_result_progress.failed,
|
|
);
|
|
}
|
|
ActivityResultMessage::SetExpected(activity_result_set_expected) => {
|
|
let activity_id = self
|
|
.activity_tree
|
|
.get_activity_id(activity_result_set_expected.id)?;
|
|
let activity = self.activity_tree.get_mut(&activity_id);
|
|
activity
|
|
.get_mut_activity()
|
|
.set_expected(activity_result_set_expected.expected);
|
|
}
|
|
ActivityResultMessage::PostBuildLogLine(
|
|
_activity_result_post_build_log_line,
|
|
) => {}
|
|
ActivityResultMessage::FetchStatus(_activity_result_fetch_status) => {}
|
|
};
|
|
}
|
|
};
|
|
Ok(())
|
|
}
|
|
}
|