Print status messages in parallel_emerge about jobs that are longer than 2 mins.

parallel_emerge

 #!/usr/bin/python2.6
 # Copyright (c) 2010 The Chromium OS Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """Program to run emerge in parallel, for significant speedup.
 
 Usage:
  ./parallel_emerge [--board=BOARD] [--workon=PKGS] [--no-workon-deps]
                    [emerge args] package"
@@ skipping 1217 matching lines @@
   for i in sorted(deps_map):
     print "%s: (%s) needs" % (i, deps_map[i]["action"])
     needs = deps_map[i]["needs"]
     for j in sorted(needs):
       print "    %s" % (j)
     if not needs:
       print "    no dependencies"
 
 
 class EmergeJobState(object):
-  __slots__ = ["done", "filename", "last_output_seek", "last_output_timestamp",
-               "pkgname", "retcode", "start_timestamp", "target"]
+  __slots__ = ["done", "filename", "last_notify_timestamp", "last_output_seek",
+               "last_output_timestamp", "pkgname", "retcode", "start_timestamp",
+               "target"]
 
   def __init__(self, target, pkgname, done, filename, start_timestamp,
                retcode=None):
 
     # The full name of the target we're building (e.g.
     # chromeos-base/chromeos-0.0.1-r60)
     self.target = target
 
     # The short name of the target we're building (e.g. chromeos-0.0.1-r60)
     self.pkgname = pkgname
 
     # Whether the job is done. (True if the job is done; false otherwise.)
     self.done = done
 
     # The filename where output is currently stored.
     self.filename = filename
 
+    # The timestamp of the last time we printed the name of the log file. We
+    # print this at the beginning of the job, so this starts at
+    # start_timestamp.
+    self.last_notify_timestamp = start_timestamp
+
     # The location (in bytes) of the end of the last complete line we printed.
     # This starts off at zero. We use this to jump to the right place when we
     # print output from the same ebuild multiple times.
     self.last_output_seek = 0
 
     # The timestamp of the last time we printed output. Since we haven't
     # printed output yet, this starts at zero.
     self.last_output_timestamp = 0
 
     # The return code of our job, if the job is actually finished.
@@ skipping 275 matching lines @@
     loads = open("/proc/loadavg", "r").readline().split()[:3]
     return " ".join(loads)
 
   def _Print(self, line):
     """Print a single line."""
     self._print_queue.put(LinePrinter(line))
 
   def _Status(self):
     """Print status."""
     current_time = time.time()
-    seconds = current_time - GLOBAL_START
-    line = ("Pending %s, Ready %s, Running %s, Retrying %s, Total %s "
-            "[Time %dm%.1fs Load %s]")
-    qsize = self._emerge_queue.qsize()
-    self._Print(line % (len(self._deps_map), qsize, len(self._jobs) - qsize,
-                        len(self._retry_queue), self._total_jobs,
-                        seconds / 60, seconds % 60, self._LoadAvg()))
+    no_output = True
 
     # Print interim output every minute if --show-output is used. Otherwise,
-    # only print output if a job has been running for 60 minutes or more.
+    # print notifications about running packages every 2 minutes, and print
+    # full output for jobs that have been running for 60 minutes or more.
     if self._show_output:
       interval = 60
+      notify_interval = 0
     else:
       interval = 60 * 60
+      notify_interval = 60 * 2
     for target, job in self._jobs.iteritems():
       if job:
         last_timestamp = max(job.start_timestamp, job.last_output_timestamp)
         if last_timestamp + interval < current_time:
           self._print_queue.put(JobPrinter(job))
           job.last_output_timestamp = current_time
+          no_output = False
+        elif (notify_interval and
+              job.last_notify_timestamp + notify_interval < current_time):
+          job_seconds = current_time - job.start_timestamp
+          args = (job.pkgname, job_seconds / 60, job_seconds % 60, job.filename)
+          info = "Still building %s (%dm%.1fs). Logs in %s" % args
+          job.last_notify_timestamp = current_time
+          self._Print(info)
+          no_output = False
+
+    # If we haven't printed any messages yet, print a general status message
+    # here.
+    if no_output:
+      seconds = current_time - GLOBAL_START
+      line = ("Pending %s, Ready %s, Running %s, Retrying %s, Total %s "
+              "[Time %dm%.1fs Load %s]")
+      qsize = self._emerge_queue.qsize()
+      self._Print(line % (len(self._deps_map), qsize, len(self._jobs) - qsize,
+                          len(self._retry_queue), self._total_jobs,
+                          seconds / 60, seconds % 60, self._LoadAvg()))
 
   def _Finish(self, target):
     """Mark a target as completed and unblock dependecies."""
     for dep in self._deps_map[target]["provides"]:
       del self._deps_map[dep]["needs"][target]
       if not self._deps_map[dep]["needs"]:
         self._Schedule(dep)
     self._deps_map.pop(target)
 
   def _Retry(self):
@@ skipping 184 matching lines @@
   # need to upgrade the rest of the packages. So we'll go ahead and do that.
   if portage_upgrade:
     args = sys.argv[1:] + ["--nomerge=sys-apps/portage"]
     os.execvp(os.path.realpath(sys.argv[0]), args)
 
   print "Done"
   sys.exit(0)
 
 if __name__ == "__main__":
   main()