Handle stdout is not compatible with tty case

Summary:
RFC: https://fb.workplace.com/groups/buck2dev/permalink/3976662752621767/

This diff handles issue when aux_stream (stdout) is not compatible with tty. It just output the raw text without escape sequence to clear the line, etc

Reviewed By: cjhopman

Differential Revision: D73564704

fbshipit-source-id: fb6dc6f5aedb279d49eb1ff74c8cd514e7db3e09

Author: Nero5023

src/builder.rs

@@ -13,6 +13,7 @@ use std::io::Write;
 use crate::Dimensions;
 use crate::SuperConsole;
 use crate::output::BlockingSuperConsoleOutput;
+use crate::output::IsTtyWrite;
 use crate::output::NonBlockingSuperConsoleOutput;
 use crate::output::SuperConsoleOutput;
 
@@ -22,7 +23,7 @@ pub struct Builder {
     // The stream that superconsole writes to by default (emit output + canvas). By default is stderr.
     stream: Box<dyn Write + Send + 'static + Sync>,
     // The stream that superconsole writes to for auxiliary output. By default is stdout.
-    aux_stream: Box<dyn Write + Send + 'static + Sync>,
+    aux_stream: Box<dyn IsTtyWrite + Send + 'static + Sync>,
 }
 
 impl Default for Builder {

src/content/lines.rs

@@ -12,6 +12,7 @@ use std::cmp::Ordering;
 use std::fmt;
 use std::fmt::Display;
 use std::fmt::Formatter;
+use std::io::Write;
 use std::iter;
 use std::mem;
 
@@ -318,6 +319,16 @@ impl Lines {
         Ok(())
     }
 
+    /// Render the lines without an escape sequence to clear the line.
+    /// It will clear the lines at the end.
+    pub(crate) fn render_raw(&mut self, writer: &mut Vec<u8>) -> anyhow::Result<()> {
+        for line in self.0.iter() {
+            writeln!(writer, "{}", line.render())?;
+        }
+        self.0.clear();
+        Ok(())
+    }
+
     pub(crate) fn lines_equal(&self, other: &Self) -> usize {
         self.0
             .iter()

src/output.rs

@@ -17,6 +17,7 @@ use crossbeam_channel::Receiver;
 use crossbeam_channel::Sender;
 use crossbeam_channel::bounded;
 use crossbeam_channel::unbounded;
+use crossterm::tty::IsTty;
 
 use crate::Dimensions;
 
@@ -29,6 +30,10 @@ pub enum OutputTarget {
     Aux,
 }
 
+pub trait IsTtyWrite: IsTty + Write {}
+
+impl<T: IsTty + Write> IsTtyWrite for T {}
+
 pub trait SuperConsoleOutput: Send + Sync + 'static {
     /// Called before rendering will occur. This has a chance to prevent rendering by returning
     /// false.
@@ -46,6 +51,11 @@ pub trait SuperConsoleOutput: Send + Sync + 'static {
         self.output(buffer)
     }
 
+    /// Check if auxillary stream is tty
+    fn aux_stream_is_tty(&self) -> bool {
+        true
+    }
+
     /// How big is the terminal to write to.
     fn terminal_size(&self) -> anyhow::Result<Dimensions> {
         Ok(crossterm::terminal::size()?.into())
@@ -66,13 +76,13 @@ pub struct BlockingSuperConsoleOutput {
     /// Stream to write to.
     stream: Box<dyn Write + Send + 'static + Sync>,
     /// Auxiliary stream to write to.
-    aux_stream: Box<dyn Write + Send + 'static + Sync>,
+    aux_stream: Box<dyn IsTtyWrite + Send + 'static + Sync>,
 }
 
 impl BlockingSuperConsoleOutput {
     pub fn new(
         stream: Box<dyn Write + Send + 'static + Sync>,
-        aux_stream: Box<dyn Write + Send + 'static + Sync>,
+        aux_stream: Box<dyn IsTtyWrite + Send + 'static + Sync>,
     ) -> Self {
         Self { stream, aux_stream }
     }
@@ -87,6 +97,10 @@ impl SuperConsoleOutput for BlockingSuperConsoleOutput {
         self.output_to(buffer, OutputTarget::Main)
     }
 
+    fn aux_stream_is_tty(&self) -> bool {
+        self.aux_stream.is_tty()
+    }
+
     fn output_to(&mut self, buffer: Vec<u8>, target: OutputTarget) -> anyhow::Result<()> {
         match target {
             OutputTarget::Main => {
@@ -127,30 +141,33 @@ pub(crate) struct NonBlockingSuperConsoleOutput {
     /// The thread doing the writing. It owns the other end of the aforementioned channels and will
     /// exit when the data sender is closed.
     handle: JoinHandle<()>,
+    /// The auxillary output is compatible with tty
+    aux_compatible: bool,
 }
 
 impl NonBlockingSuperConsoleOutput {
     pub fn new(
         stream: Box<dyn Write + Send + 'static + Sync>,
-        aux_stream: Box<dyn Write + Send + 'static + Sync>,
+        aux_stream: Box<dyn IsTtyWrite + Send + 'static + Sync>,
     ) -> anyhow::Result<Self> {
         Self::new_for_writer(stream, aux_stream)
     }
 
     fn new_for_writer(
         mut stream: Box<dyn Write + Send + 'static + Sync>,
-        mut aux_stream: Box<dyn Write + Send + 'static + Sync>,
+        mut aux_stream: Box<dyn IsTtyWrite + Send + 'static + Sync>,
     ) -> anyhow::Result<Self> {
         let (sender, receiver) = bounded::<(Vec<u8>, OutputTarget)>(1);
         let (error_sender, errors) = unbounded::<io::Error>();
+        let aux_compatible = aux_stream.is_tty();
 
         let handle = std::thread::Builder::new()
             .name("superconsole-io".to_owned())
             .spawn(move || {
                 for (data, output_target) in receiver.into_iter() {
                     let out_stream = match output_target {
                         OutputTarget::Main => &mut stream,
-                        OutputTarget::Aux => &mut aux_stream,
+                        OutputTarget::Aux => &mut aux_stream as &mut dyn Write,
                     };
                     match out_stream.write_all(&data).and_then(|()| stream.flush()) {
                         Ok(()) => {}
@@ -168,6 +185,7 @@ impl NonBlockingSuperConsoleOutput {
             sender,
             errors,
             handle,
+            aux_compatible,
         })
     }
 }
@@ -198,12 +216,17 @@ impl SuperConsoleOutput for NonBlockingSuperConsoleOutput {
         Ok(())
     }
 
+    fn aux_stream_is_tty(&self) -> bool {
+        self.aux_compatible
+    }
+
     /// Notify our writer thread that no further writes are expected. Wait for it to flush.
     fn finalize(self: Box<Self>) -> anyhow::Result<()> {
         let Self {
             sender,
             errors,
             handle,
+            aux_compatible: _,
         } = *self;
         drop(sender);
 
@@ -247,6 +270,12 @@ mod tests {
         }
     }
 
+    impl IsTty for TestWriter {
+        fn is_tty(&self) -> bool {
+            true
+        }
+    }
+
     impl Write for TestWriter {
         fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
             self.sender

src/superconsole.rs

@@ -241,17 +241,24 @@ impl SuperConsole {
         // We don't trust the child to not truncate the result.
         canvas.shrink_lines_to_dimensions(size);
 
+        // The closure to compute the limit to render the emit lines above the canvas.
         // Render at most a single frame if this not the last render.
         // Does not buffer if there is a ridiculous amount of data.
-        let mut limit = match mode {
-            DrawMode::Normal if !is_big(&self.to_emit, &self.aux_to_emit) => {
-                let limit = size.height.saturating_sub(canvas.len());
-                // arbitrary value picked so we don't starve `emit` on small terminal sizes.
-                Some(cmp::max(limit, MINIMUM_EMIT))
+        let compute_limit = |buf0: &Lines, buf1: &Lines| {
+            match mode {
+                DrawMode::Normal if !is_big(buf0, buf1) => {
+                    let limit = size.height.saturating_sub(canvas.len());
+                    // arbitrary value picked so we don't starve `emit` on small terminal sizes.
+                    Some(cmp::max(limit, MINIMUM_EMIT))
+                }
+                _ => None,
             }
-            _ => None,
         };
 
+        // Render at most a single frame if this not the last render.
+        // Does not buffer if there is a ridiculous amount of data.
+        let mut limit = compute_limit(&self.to_emit, &self.aux_to_emit);
+
         // How much of the canvas hasn't changed, so I can avoid overwriting
         // and thus avoid flickering things like URL's in VS Code terminal.
         let reuse_prefix = if self.to_emit.is_empty() && self.aux_to_emit.is_empty() {
@@ -265,15 +272,25 @@ impl SuperConsole {
         Self::clear_canvas_pre(&mut buffer, self.canvas_contents.len() - reuse_prefix)?;
 
         if !self.aux_to_emit.is_empty() {
-            // If we have aux_to_emit, we need to output the main output (stderr by default) first
-            // and flushed, so that we can make sure the all output order is correct.
-            self.output.output(buffer)?;
-            let mut aux_buffer = Vec::new();
-            limit = self.aux_to_emit.render_with_limit(&mut aux_buffer, limit)?;
-            self.output.output_to(aux_buffer, OutputTarget::Aux)?;
-
-            // Since output is moved at `self.output.output(buffer)`, we need to new a new buffer
-            buffer = Vec::new();
+            if self.output.aux_stream_is_tty() {
+                // If we have aux_to_emit and the aux stream is tty, we need to output the main output (stderr by default) first
+                // and flushed, so that we can make sure the all output order is correct.
+                self.output.output(buffer)?;
+                let mut aux_buffer = Vec::new();
+                limit = self.aux_to_emit.render_with_limit(&mut aux_buffer, limit)?;
+                self.output.output_to(aux_buffer, OutputTarget::Aux)?;
+
+                // Since output is moved at `self.output.output(buffer)`, we need to new a new buffer
+                buffer = Vec::new();
+            } else {
+                // If the aux stream is not tty, we don't need to render the line, we just output to the auxillary output
+                let mut output_buffer = Vec::new();
+                self.aux_to_emit.render_raw(&mut output_buffer)?;
+                self.output.output_to(output_buffer, OutputTarget::Aux)?;
+
+                // Since we clear the aux_to_emit, we need to recompute the `limit`
+                limit = compute_limit(&self.to_emit, &self.aux_to_emit);
+            }
         }
 
         self.to_emit.render_with_limit(&mut buffer, limit)?;
@@ -299,6 +316,7 @@ mod tests {
     use crate::testing::TestOutput;
     use crate::testing::frame_contains;
     use crate::testing::test_console;
+    use crate::testing::test_console_aux_incompatible;
 
     #[derive(AsRef, Debug)]
     #[allow(dead_code)]
@@ -587,4 +605,29 @@ mod tests {
 
         Ok(())
     }
+
+    #[test]
+    fn test_emit_aux_with_aux_incompatible_output() -> anyhow::Result<()> {
+        let mut console = test_console_aux_incompatible();
+
+        let root = Echo(Lines(vec![vec!["state"].try_into()?]));
+        console.emit_aux(Lines(vec![vec!["aux line 1"].try_into()?]));
+        console.emit_aux(Lines(vec![vec!["aux line 2"].try_into()?]));
+        console.render(&root)?;
+
+        // Since we emit aux, we don't output the whole frame once in TestConsole
+        let frame: Vec<u8> = console
+            .test_output_mut()?
+            .frames
+            .iter()
+            .flatten()
+            .copied()
+            .collect();
+        println!("frame: {:?}", String::from_utf8_lossy(&frame));
+        assert!(frame_contains(&frame, "state"));
+        // Since aux output is incompatible with tty, we don't output the any escape sequence to clear the line.
+        assert!(frame_contains(&frame, "aux line 1\naux line 2"));
+
+        Ok(())
+    }
 }

src/testing.rs

@@ -25,6 +25,8 @@ pub struct TestOutput {
     pub terminal_size: Dimensions,
     /// The frames that were written to this output.
     pub frames: Vec<Vec<u8>>,
+    /// Whether auxiliary output is compatible with tty
+    aux_stream_is_tty: bool,
 }
 
 impl TestOutput {
@@ -63,6 +65,10 @@ impl SuperConsoleOutput for TestOutput {
         }
     }
 
+    fn aux_stream_is_tty(&self) -> bool {
+        self.aux_stream_is_tty
+    }
+
     fn terminal_size(&self) -> anyhow::Result<Dimensions> {
         Ok(self.terminal_size)
     }
@@ -102,6 +108,14 @@ impl SuperConsoleTestingExt for SuperConsole {
 }
 
 pub fn test_console() -> SuperConsole {
+    test_console_inner(true)
+}
+
+pub fn test_console_aux_incompatible() -> SuperConsole {
+    test_console_inner(false)
+}
+
+fn test_console_inner(aux_stream_is_tty: bool) -> SuperConsole {
     let size = Dimensions {
         width: 80,
         height: 80,
@@ -112,6 +126,7 @@ pub fn test_console() -> SuperConsole {
             should_render: true,
             terminal_size: size,
             frames: Vec::new(),
+            aux_stream_is_tty,
         }),
     )
 }