( )⚙ D8870 rhg: extract function handle_stdout_error

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
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

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 22253

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))
} }
}