refactor(progress bars): global control for drawing (#17091)

This PR adds the concept of a global `DrawThread`, which can receive
multiple renderers to draw information on the screen (note: the
underlying thread is released back to tokio when it's not rendering). It
also separates the concept of progress bars from the existing "draw
thread". This makes it trivial for us to do stuff like show permission
prompts and progress bars at the same time in the future.

The reason this is global is because the process' tty stderr is also a
global concept.

1 files changed, 0 insertions, 218 deletions

diff --git a/cli/util/progress_bar/draw_thread.rs b/cli/util/progress_bar/draw_thread.rs
deleted file mode 100644
index 89e8ab53f..000000000
--- a/cli/util/progress_bar/draw_thread.rs
+++ /dev/null
@@ -1,218 +0,0 @@
-// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.
-
-use console_static_text::ConsoleStaticText;
-use deno_core::parking_lot::Mutex;
-use std::sync::atomic::AtomicU64;
-use std::sync::atomic::Ordering;
-use std::sync::Arc;
-use std::time::Duration;
-use std::time::SystemTime;
-
-use crate::util::console::console_size;
-
-use super::renderer::ProgressBarRenderer;
-use super::renderer::ProgressData;
-use super::renderer::ProgressDataDisplayEntry;
-
-#[derive(Clone, Debug)]
-pub struct ProgressBarEntry {
-  id: usize,
-  pub message: String,
-  pos: Arc<AtomicU64>,
-  total_size: Arc<AtomicU64>,
-  draw_thread: DrawThread,
-}
-
-impl ProgressBarEntry {
-  pub fn position(&self) -> u64 {
-    self.pos.load(Ordering::Relaxed)
-  }
-
-  pub fn set_position(&self, new_pos: u64) {
-    self.pos.store(new_pos, Ordering::Relaxed);
-  }
-
-  pub fn total_size(&self) -> u64 {
-    self.total_size.load(Ordering::Relaxed)
-  }
-
-  pub fn set_total_size(&self, new_size: u64) {
-    self.total_size.store(new_size, Ordering::Relaxed);
-  }
-
-  pub fn finish(&self) {
-    self.draw_thread.finish_entry(self.id);
-  }
-
-  pub fn percent(&self) -> f64 {
-    let pos = self.pos.load(Ordering::Relaxed) as f64;
-    let total_size = self.total_size.load(Ordering::Relaxed) as f64;
-    if total_size == 0f64 {
-      0f64
-    } else {
-      pos / total_size
-    }
-  }
-}
-
-#[derive(Debug)]
-struct InternalState {
-  start_time: SystemTime,
-  // this ensures only one draw thread is running
-  drawer_id: usize,
-  keep_alive_count: usize,
-  has_draw_thread: bool,
-  total_entries: usize,
-  entries: Vec<ProgressBarEntry>,
-  static_text: ConsoleStaticText,
-  renderer: Box<dyn ProgressBarRenderer>,
-}
-
-#[derive(Clone, Debug)]
-pub struct DrawThread {
-  state: Arc<Mutex<InternalState>>,
-}
-
-impl DrawThread {
-  pub fn new(renderer: Box<dyn ProgressBarRenderer>) -> Self {
-    Self {
-      state: Arc::new(Mutex::new(InternalState {
-        start_time: SystemTime::now(),
-        drawer_id: 0,
-        keep_alive_count: 0,
-        has_draw_thread: false,
-        total_entries: 0,
-        entries: Vec::new(),
-        static_text: ConsoleStaticText::new(|| {
-          let size = console_size().unwrap();
-          console_static_text::ConsoleSize {
-            cols: Some(size.cols as u16),
-            rows: Some(size.rows as u16),
-          }
-        }),
-        renderer,
-      })),
-    }
-  }
-
-  pub fn add_entry(&self, message: String) -> ProgressBarEntry {
-    let mut internal_state = self.state.lock();
-    let id = internal_state.total_entries;
-    let entry = ProgressBarEntry {
-      id,
-      draw_thread: self.clone(),
-      message,
-      pos: Default::default(),
-      total_size: Default::default(),
-    };
-    internal_state.entries.push(entry.clone());
-    internal_state.total_entries += 1;
-    internal_state.keep_alive_count += 1;
-
-    if !internal_state.has_draw_thread {
-      self.start_draw_thread(&mut internal_state);
-    }
-
-    entry
-  }
-
-  fn finish_entry(&self, entry_id: usize) {
-    let mut internal_state = self.state.lock();
-
-    if let Ok(index) = internal_state
-      .entries
-      .binary_search_by(|e| e.id.cmp(&entry_id))
-    {
-      internal_state.entries.remove(index);
-      self.decrement_keep_alive(&mut internal_state);
-    }
-  }
-
-  pub fn increment_clear(&self) {
-    let mut internal_state = self.state.lock();
-    internal_state.keep_alive_count += 1;
-  }
-
-  pub fn decrement_clear(&self) {
-    let mut internal_state = self.state.lock();
-    self.decrement_keep_alive(&mut internal_state);
-  }
-
-  fn decrement_keep_alive(&self, internal_state: &mut InternalState) {
-    internal_state.keep_alive_count -= 1;
-
-    if internal_state.keep_alive_count == 0 {
-      internal_state.static_text.eprint_clear();
-      // bump the drawer id to exit the draw thread
-      internal_state.drawer_id += 1;
-      internal_state.has_draw_thread = false;
-    }
-  }
-
-  fn start_draw_thread(&self, internal_state: &mut InternalState) {
-    internal_state.drawer_id += 1;
-    internal_state.start_time = SystemTime::now();
-    internal_state.has_draw_thread = true;
-    let drawer_id = internal_state.drawer_id;
-    let internal_state = self.state.clone();
-    tokio::task::spawn_blocking(move || {
-      let mut previous_size = console_size().unwrap();
-      loop {
-        let mut delay_ms = 120;
-        {
-          let mut internal_state = internal_state.lock();
-          // exit if not the current draw thread
-          if internal_state.drawer_id != drawer_id {
-            break;
-          }
-
-          let size = console_size().unwrap();
-          if size != previous_size {
-            // means the user is actively resizing the console...
-            // wait a little bit until they stop resizing
-            previous_size = size;
-            delay_ms = 200;
-          } else if !internal_state.entries.is_empty() {
-            let preferred_entry = internal_state
-              .entries
-              .iter()
-              .find(|e| e.percent() > 0f64)
-              .or_else(|| internal_state.entries.iter().last())
-              .unwrap();
-            let text = internal_state.renderer.render(ProgressData {
-              duration: internal_state.start_time.elapsed().unwrap(),
-              terminal_width: size.cols,
-              pending_entries: internal_state.entries.len(),
-              total_entries: internal_state.total_entries,
-              display_entry: ProgressDataDisplayEntry {
-                message: preferred_entry.message.clone(),
-                position: preferred_entry.position(),
-                total_size: preferred_entry.total_size(),
-              },
-              percent_done: {
-                let mut total_percent_sum = 0f64;
-                for entry in &internal_state.entries {
-                  total_percent_sum += entry.percent();
-                }
-                total_percent_sum += (internal_state.total_entries
-                  - internal_state.entries.len())
-                  as f64;
-                total_percent_sum / (internal_state.total_entries as f64)
-              },
-            });
-
-            internal_state.static_text.eprint_with_size(
-              &text,
-              console_static_text::ConsoleSize {
-                cols: Some(size.cols as u16),
-                rows: Some(size.rows as u16),
-              },
-            );
-          }
-        }
-
-        std::thread::sleep(Duration::from_millis(delay_ms));
-      }
-    });
-  }
-}