This is an archive of the discontinued Mercurial Phabricator instance.

Differential D8870

rhg: extract function handle_stdout_error
ClosedPublic

Authored by acezar on Aug 3 2020, 10:26 AM.

Details

Reviewers
Alphare
indygreg
Group Reviewers
hg-reviewers
Commits
rHG10c36ead86f8: rhg: extract function handle_stdout_error
Summary

Avoid repeating the logic of handling stdout write errors.

Diff Detail

Repository
rHG Mercurial
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Event Timeline

acezar created this revision.Aug 3 2020, 10:26 AM
Alphare accepted this revision.Aug 3 2020, 11:21 AM
acezar updated this revision to Diff 22253.Aug 4 2020, 4:58 AM
indygreg accepted this revision.Aug 8 2020, 4:12 PM
This revision is now accepted and ready to land.Aug 8 2020, 4:12 PM
acezar added a commit: rHG10c36ead86f8: rhg: extract function handle_stdout_error.Aug 8 2020, 4:31 PM
Closed by commit rHG10c36ead86f8: rhg: extract function handle_stdout_error (authored by acezar). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mrust/rhg/src/ui.rs (71 lines)

Diff 22365

rust/rhg/src/ui.rs

pub fn stdout_buffer(&self) -> StdoutBuffer<std::io::StdoutLock> { pub fn stdout_buffer(&self) -> StdoutBuffer<std::io::StdoutLock> {
StdoutBuffer::new(self.stdout.lock()) StdoutBuffer::new(self.stdout.lock())
} }
/// Write bytes to stdout /// Write bytes to stdout
pub fn write_stdout(&self, bytes: &[u8]) -> Result<(), UiError> { pub fn write_stdout(&self, bytes: &[u8]) -> Result<(), UiError> {
let mut stdout = self.stdout.lock(); let mut stdout = self.stdout.lock();
self.write_stream(&mut stdout, bytes) stdout
.or_else(|e| self.handle_stdout_error(e))?; .write_all(bytes)
.or_else(|e| handle_stdout_error(e))?;
stdout.flush().or_else(|e| self.handle_stdout_error(e)) stdout.flush().or_else(|e| handle_stdout_error(e))
}
/// Sometimes writing to stdout is not possible, try writing to stderr to
/// signal that failure, otherwise just bail.
fn handle_stdout_error(&self, error: io::Error) -> Result<(), UiError> {
self.write_stderr(
&[b"abort: ", error.to_string().as_bytes(), b"\n"].concat(),
)?;
Err(UiError::StdoutError(error))
} }
/// Write bytes to stderr /// Write bytes to stderr
pub fn write_stderr(&self, bytes: &[u8]) -> Result<(), UiError> { pub fn write_stderr(&self, bytes: &[u8]) -> Result<(), UiError> {
let mut stderr = self.stderr.lock(); let mut stderr = self.stderr.lock();
self.write_stream(&mut stderr, bytes) stderr
.or_else(|e| Err(UiError::StderrError(e)))?; .write_all(bytes)
.or_else(|e| handle_stderr_error(e))?;
stderr.flush().or_else(|e| Err(UiError::StderrError(e))) stderr.flush().or_else(|e| Err(UiError::StderrError(e)))
} }
fn write_stream(
&self,
stream: &mut impl Write,
bytes: &[u8],
) -> Result<(), io::Error> {
stream.write_all(bytes)
}
} }
/// A buffered stdout writer for faster batch printing operations. /// A buffered stdout writer for faster batch printing operations.
pub struct StdoutBuffer<W: Write> { pub struct StdoutBuffer<W: Write> {
buf: io::BufWriter<W>, buf: io::BufWriter<W>,
} }
impl<W: Write> StdoutBuffer<W> { impl<W: Write> StdoutBuffer<W> {
pub fn new(writer: W) -> Self { pub fn new(writer: W) -> Self {
let buf = io::BufWriter::new(writer); let buf = io::BufWriter::new(writer);
Self { buf } Self { buf }
} }
/// Write bytes to stdout buffer /// Write bytes to stdout buffer
pub fn write_all(&mut self, bytes: &[u8]) -> Result<(), UiError> { pub fn write_all(&mut self, bytes: &[u8]) -> Result<(), UiError> {
self.buf.write_all(bytes).or_else(|e| self.io_err(e)) self.buf
.write_all(bytes)
.or_else(|e| handle_stdout_error(e))
} }
/// Flush bytes to stdout /// Flush bytes to stdout
pub fn flush(&mut self) -> Result<(), UiError> { pub fn flush(&mut self) -> Result<(), UiError> {
self.buf.flush().or_else(|e| self.io_err(e)) self.buf.flush().or_else(|e| handle_stdout_error(e))
}
} }
fn io_err(&self, error: io::Error) -> Result<(), UiError> { /// Sometimes writing to stdout is not possible, try writing to stderr to
/// signal that failure, otherwise just bail.
fn handle_stdout_error(error: io::Error) -> Result<(), UiError> {
if let ErrorKind::BrokenPipe = error.kind() { if let ErrorKind::BrokenPipe = error.kind() {
// This makes `| head` work for example // This makes `| head` work for example
return Ok(()); return Ok(());
} }
let mut stderr = io::stderr(); let mut stderr = io::stderr();
stderr stderr
.write_all( .write_all(&[b"abort: ", error.to_string().as_bytes(), b"\n"].concat())
&[b"abort: ", error.to_string().as_bytes(), b"\n"].concat(),
)
.map_err(|e| UiError::StderrError(e))?; .map_err(|e| UiError::StderrError(e))?;
stderr.flush().map_err(|e| UiError::StderrError(e))?; stderr.flush().map_err(|e| UiError::StderrError(e))?;
Err(UiError::StdoutError(error)) Err(UiError::StdoutError(error))
} }
}