From 7831cb81000c7bc99181e0fe8db6e3d5996e834c Mon Sep 17 00:00:00 2001
From: Allan Odgaard <git@abetarda.com>
Date: Sat, 3 Aug 2013 00:45:05 +0200
Subject: [PATCH] If we are waiting for only one edge, print status for that
 edge
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

With this patch, should the build stall, it should be clear what edge is responsible.

The patch introduces BuildStatus::last_edge_status_ to keep track of the last edge we printed status for. This is to avoid printing status for the same edge twice, which is mainly when the output doesn’t overwrite previously printed output (non-smart terminal).

It would be better to delay re-printing status until we have waited a certain amount of time, which would also allow us to handle the case where more than one edge is stalling the build, but this require some refactoring, as waiting for tasks is presently done without the ability to specify a timeout.
---
 src/build.cc | 16 ++++++++++++++++
 src/build.h  |  2 ++
 2 files changed, 18 insertions(+)

diff --git a/src/build.cc b/src/build.cc
index 45f684921f..0abf42f144 100644
--- a/src/build.cc
+++ b/src/build.cc
@@ -74,6 +74,7 @@ BuildStatus::BuildStatus(const BuildConfig& config)
     : config_(config),
       start_time_millis_(GetTimeMillis()),
       started_edges_(0), finished_edges_(0), total_edges_(0),
+      last_edge_status_(0),
       progress_status_format_(NULL),
       overall_rate_(), current_rate_(config.parallelism) {
 
@@ -98,6 +99,15 @@ void BuildStatus::BuildEdgeStarted(Edge* edge) {
   PrintStatus(edge);
 }
 
+void BuildStatus::PrintBuildEdgeStatus() {
+  if (running_edges_.size() == 1) {
+    Edge* running_edge = running_edges_.begin()->first;
+    if(last_edge_status_ != running_edge) {
+      PrintStatus(running_edge);
+    }
+  }
+}
+
 void BuildStatus::BuildEdgeFinished(Edge* edge,
                                     bool success,
                                     const string& output,
@@ -117,6 +127,9 @@ void BuildStatus::BuildEdgeFinished(Edge* edge,
   if (printer_.is_smart_terminal())
     PrintStatus(edge);
 
+  if (last_edge_status_ == edge)
+    last_edge_status_ = 0;
+
   // Print the command that is spewing before printing its output.
   if (!success)
     printer_.PrintOnNewLine("FAILED: " + edge->EvaluateCommand() + "\n");
@@ -248,6 +261,7 @@ void BuildStatus::PrintStatus(Edge* edge) {
 
   printer_.Print(to_print,
                  force_full_command ? LinePrinter::FULL : LinePrinter::ELIDE);
+  last_edge_status_ = edge;
 }
 
 Plan::Plan() : command_edges_(0), wanted_edges_(0) {}
@@ -630,6 +644,8 @@ bool Builder::Build(string* err) {
 
     // See if we can reap any finished commands.
     if (pending_commands) {
+      status_->PrintBuildEdgeStatus();
+
       CommandRunner::Result result;
       if (!command_runner_->WaitForCommand(&result) ||
           result.status == ExitInterrupted) {
diff --git a/src/build.h b/src/build.h
index 33df7d0d47..56b3343158 100644
--- a/src/build.h
+++ b/src/build.h
@@ -196,6 +196,7 @@ struct BuildStatus {
   explicit BuildStatus(const BuildConfig& config);
   void PlanHasTotalEdges(int total);
   void BuildEdgeStarted(Edge* edge);
+  void PrintBuildEdgeStatus();
   void BuildEdgeFinished(Edge* edge, bool success, const string& output,
                          int* start_time, int* end_time);
   void BuildFinished();
@@ -219,6 +220,7 @@ struct BuildStatus {
   /// Map of running edge to time the edge started running.
   typedef map<Edge*, int> RunningEdgeMap;
   RunningEdgeMap running_edges_;
+  Edge* last_edge_status_;
 
   /// Prints progress output.
   LinePrinter printer_;