Displays a one line progress of what crates are currently built.

cc rust-lang#2536, rust-lang#3448.

src/cargo/core/compiler/job_queue.rs

@@ -14,6 +14,7 @@ use core::{PackageId, Target};
 use handle_error;
 use util::{internal, profile, CargoResult, CargoResultExt, ProcessBuilder};
 use util::{Config, DependencyQueue, Dirty, Fresh, Freshness};
+use util::Progress;
 
 use super::job::Job;
 use super::{BuildContext, BuildPlan, CompileMode, Context, Kind, Unit};
@@ -28,7 +29,7 @@ pub struct JobQueue<'a> {
  queue: DependencyQueue<Key<'a>, Vec<(Job, Freshness)>>,
  tx: Sender<Message<'a>>,
  rx: Receiver<Message<'a>>,
- active: usize,
+ active: HashSet<Key<'a>>,
  pending: HashMap<Key<'a>, PendingBuild>,
  compiled: HashSet<&'a PackageId>,
  documented: HashSet<&'a PackageId>,
@@ -98,7 +99,7 @@ impl<'a> JobQueue<'a> {
  queue: DependencyQueue::new(),
  tx,
  rx,
- active: 0,
+ active: HashSet::new(),
  pending: HashMap::new(),
  compiled: HashSet::new(),
  documented: HashSet::new(),
@@ -180,6 +181,8 @@ impl<'a> JobQueue<'a> {
  // successful and otherwise wait for pending work to finish if it failed
  // and then immediately return.
  let mut error = None;
+ let mut progress = Progress::new("Building", cx.bcx.config);
+ let queue_len = self.queue.len();
  loop {
  // Dequeue as much work as we can, learning about everything
  // possible that can run. Note that this is also the point where we
@@ -196,7 +199,7 @@ impl<'a> JobQueue<'a> {
  );
  for (job, f) in jobs {
  queue.push((key, job, f.combine(fresh)));
- if self.active + queue.len() > 0 {
+ if !self.active.is_empty() || !queue.is_empty() {
  jobserver_helper.request_token();
  }
  }
@@ -205,14 +208,14 @@ impl<'a> JobQueue<'a> {
  // Now that we've learned of all possible work that we can execute
  // try to spawn it so long as we've got a jobserver token which says
  // we're able to perform some parallel work.
- while error.is_none() && self.active < tokens.len() + 1 && !queue.is_empty() {
+ while error.is_none() && self.active.len() < tokens.len() + 1 && !queue.is_empty() {
  let (key, job, fresh) = queue.remove(0);
  self.run(key, fresh, job, cx.bcx.config, scope, build_plan)?;
  }
 
  // If after all that we're not actually running anything then we're
  // done!
- if self.active == 0 {
+ if self.active.is_empty() {
  break;
  }
 
@@ -221,9 +224,19 @@ impl<'a> JobQueue<'a> {
  // jobserver interface is architected we may acquire a token that we
  // don't actually use, and if this happens just relinquish it back
  // to the jobserver itself.
- tokens.truncate(self.active - 1);
-
- match self.rx.recv().unwrap() {
+ tokens.truncate(self.active.len() - 1);
+
+ let count = queue_len - self.queue.len();
+ let mut active_names = self.active.iter().map(|key| match key.mode {
+ CompileMode::Doc { .. } => format!("{}(doc)", key.pkg.name()),
+ _ => key.pkg.name().to_string(),
+ }).collect::<Vec<_>>();
+ active_names.sort_unstable();
+ drop(progress.tick_now(count, queue_len, format!(": {}", active_names.join(", "))));
+ let event = self.rx.recv().unwrap();
+ progress.clear();
+
+ match event {
  Message::Run(cmd) => {
  cx.bcx
  .config
@@ -245,8 +258,9 @@ impl<'a> JobQueue<'a> {
  }
  Message::Finish(key, result) => {
  info!("end: {:?}", key);
- self.active -= 1;
- if self.active > 0 {
+
+ self.active.remove(&key);
+ if !self.active.is_empty() {
  assert!(!tokens.is_empty());
  drop(tokens.pop());
  }
@@ -256,7 +270,7 @@ impl<'a> JobQueue<'a> {
  let msg = "The following warnings were emitted during compilation:";
  self.emit_warnings(Some(msg), &key, cx)?;
 
- if self.active > 0 {
+ if !self.active.is_empty() {
  error = Some(format_err!("build failed"));
  handle_error(e, &mut *cx.bcx.config.shell());
  cx.bcx.config.shell().warn(
@@ -274,6 +288,7 @@ impl<'a> JobQueue<'a> {
  }
  }
  }
+ drop(progress);
 
  let build_type = if self.is_release { "release" } else { "dev" };
  // NOTE: This may be a bit inaccurate, since this may not display the
@@ -334,7 +349,7 @@ impl<'a> JobQueue<'a> {
  ) -> CargoResult<()> {
  info!("start: {:?}", key);
 
- self.active += 1;
+ self.active.insert(key);
  *self.counts.get_mut(key.pkg).unwrap() -= 1;
 
  let my_tx = self.tx.clone();

src/cargo/util/progress.rs

@@ -1,6 +1,5 @@
 use std::cmp;
 use std::env;
-use std::iter;
 use std::time::{Duration, Instant};
 
 use core::shell::Verbosity;
@@ -12,6 +11,7 @@ pub struct Progress<'cfg> {
 
 struct State<'cfg> {
  config: &'cfg Config,
+ max_width: usize,
  width: usize,
  first: bool,
  last_update: Instant,
@@ -33,6 +33,7 @@ impl<'cfg> Progress<'cfg> {
  Progress {
  state: cfg.shell().err_width().map(|n| State {
  config: cfg,
+ max_width: n,
  width: cmp::min(n, 80),
  first: true,
  last_update: Instant::now(),
@@ -44,14 +45,27 @@ impl<'cfg> Progress<'cfg> {
 
  pub fn tick(&mut self, cur: usize, max: usize) -> CargoResult<()> {
  match self.state {
- Some(ref mut s) => s.tick(cur, max),
+ Some(ref mut s) => s.tick(cur, max, String::new(), true),
+ None => Ok(()),
+ }
+ }
+
+ pub fn clear(&mut self) {
+ if let Some(ref mut s) = self.state {
+ clear(s.max_width, s.config);
+ }
+ }
+
+ pub fn tick_now(&mut self, cur: usize, max: usize, msg: String) -> CargoResult<()> {
+ match self.state {
+ Some(ref mut s) => s.tick(cur, max, msg, false),
  None => Ok(()),
  }
  }
 }
 
 impl<'cfg> State<'cfg> {
- fn tick(&mut self, cur: usize, max: usize) -> CargoResult<()> {
+ fn tick(&mut self, cur: usize, max: usize, msg: String, throttle: bool) -> CargoResult<()> {
  if self.done {
  return Ok(());
  }
@@ -68,19 +82,21 @@ impl<'cfg> State<'cfg> {
  // 2. If we've drawn something, then we rate limit ourselves to only
  // draw to the console every so often. Currently there's a 100ms
  // delay between updates.
- if self.first {
- let delay = Duration::from_millis(500);
- if self.last_update.elapsed() < delay {
- return Ok(());
- }
- self.first = false;
- } else {
- let interval = Duration::from_millis(100);
- if self.last_update.elapsed() < interval {
- return Ok(());
+ if throttle {
+ if self.first {
+ let delay = Duration::from_millis(500);
+ if self.last_update.elapsed() < delay {
+ return Ok(());
+ }
+ self.first = false;
+ } else {
+ let interval = Duration::from_millis(100);
+ if self.last_update.elapsed() < interval {
+ return Ok(());
+ }
  }
+ self.last_update = Instant::now();
  }
- self.last_update = Instant::now();
 
  // Render the percentage at the far right and then figure how long the
  // progress bar is
@@ -116,6 +132,14 @@ impl<'cfg> State<'cfg> {
  string.push_str("]");
  string.push_str(&stats);
 
+ let avail_msg_len = self.max_width - self.width;
+ if avail_msg_len >= msg.len() + 3 {
+ string.push_str(&msg);
+ } else if avail_msg_len >= 4 {
+ string.push_str(&msg[..(avail_msg_len - 3)]);
+ string.push_str("...");
+ }
+
  // Write out a pretty header, then the progress bar itself, and then
  // return back to the beginning of the line for the next print.
  self.config.shell().status_header(&self.name)?;
@@ -125,12 +149,12 @@ impl<'cfg> State<'cfg> {
 }
 
 fn clear(width: usize, config: &Config) {
- let blank = iter::repeat(" ").take(width).collect::<String>();
+ let blank = " ".repeat(width);
  drop(write!(config.shell().err(), "{}\r", blank));
 }
 
 impl<'cfg> Drop for State<'cfg> {
  fn drop(&mut self) {
- clear(self.width, self.config);
+ clear(self.max_width, self.config);
  }
 }