mirror of
https://github.com/nushell/nushell.git
synced 2025-08-09 11:45:50 +02:00
Refactor I/O Errors (#14927)
<!--
if this PR closes one or more issues, you can automatically link the PR
with
them by using one of the [*linking
keywords*](https://docs.github.com/en/issues/tracking-your-work-with-issues/linking-a-pull-request-to-an-issue#linking-a-pull-request-to-an-issue-using-a-keyword),
e.g.
- this PR should close #xxxx
- fixes #xxxx
you can also mention related issues, PRs or discussions!
-->
# Description
<!--
Thank you for improving Nushell. Please, check our [contributing
guide](../CONTRIBUTING.md) and talk to the core team before making major
changes.
Description of your pull request goes here. **Provide examples and/or
screenshots** if your changes affect the user experience.
-->
As mentioned in #10698, we have too many `ShellError` variants, with
some even overlapping in meaning. This PR simplifies and improves I/O
error handling by restructuring `ShellError` related to I/O issues.
Previously, `ShellError::IOError` only contained a message string,
making it convenient but overly generic. It was widely used without
providing spans (#4323).
This PR introduces a new `ShellError::Io` variant that consolidates
multiple I/O-related errors (except for `ShellError::NetworkFailure`,
which remains distinct for now). The new `ShellError::Io` variant
replaces the following:
- `FileNotFound`
- `FileNotFoundCustom`
- `IOInterrupted`
- `IOError`
- `IOErrorSpanned`
- `NotADirectory`
- `DirectoryNotFound`
- `MoveNotPossible`
- `CreateNotPossible`
- `ChangeAccessTimeNotPossible`
- `ChangeModifiedTimeNotPossible`
- `RemoveNotPossible`
- `ReadingFile`
## The `IoError`
`IoError` includes the following fields:
1. **`kind`**: Extends `std::io::ErrorKind` to specify the type of I/O
error without needing new `ShellError` variants. This aligns with the
approach used in `std::io::Error`. This adds a second dimension to error
reporting by combining the `kind` field with `ShellError` variants,
making it easier to describe errors in more detail. As proposed by
@kubouch in [#design-discussion on
Discord](https://discord.com/channels/601130461678272522/615329862395101194/1323699197165178930),
this helps reduce the number of `ShellError` variants. In the error
report, the `kind` field is displayed as the "source" of the error,
e.g., "I/O error," followed by the specific kind of I/O error.
2. **`span`**: A non-optional field to encourage providing spans for
better error reporting (#4323).
3. **`path`**: Optional `PathBuf` to give context about the file or
directory involved in the error (#7695). If provided, it’s shown as a
help entry in error reports.
4. **`additional_context`**: Allows adding custom messages when the
span, kind, and path are insufficient. This is rendered in the error
report at the labeled span.
5. **`location`**: Sometimes, I/O errors occur in the engine itself and
are not caused directly by user input. In such cases, if we don’t have a
span and must set it to `Span::unknown()`, we need another way to
reference the error. For this, the `location` field uses the new
`Location` struct, which records the Rust file and line number where the
error occurred. This ensures that we at least know the Rust code
location that failed, helping with debugging. To make this work, a new
`location!` macro was added, which retrieves `file!`, `line!`, and
`column!` values accurately. If `Location::new` is used directly, it
issues a warning to remind developers to use the macro instead, ensuring
consistent and correct usage.
### Constructor Behavior
`IoError` provides five constructor methods:
- `new` and `new_with_additional_context`: Used for errors caused by
user input and require a valid (non-unknown) span to ensure precise
error reporting.
- `new_internal` and `new_internal_with_path`: Used for internal errors
where a span is not available. These methods require additional context
and the `Location` struct to pinpoint the source of the error in the
engine code.
- `factory`: Returns a closure that maps an `std::io::Error` to an
`IoError`. This is useful for handling multiple I/O errors that share
the same span and path, streamlining error handling in such cases.
## New Report Look
This is simulation how the I/O errors look like (the `open crates` is
simulated to show how internal errors are referenced now):
## `Span::test_data()`
To enable better testing, `Span::test_data()` now returns a value
distinct from `Span::unknown()`. Both `Span::test_data()` and
`Span::unknown()` refer to invalid source code, but having a separate
value for test data helps identify issues during testing while keeping
spans unique.
## Cursed Sneaky Error Transfers
I removed the conversions between `std::io::Error` and `ShellError` as
they often removed important information and were used too broadly to
handle I/O errors. This also removed the problematic implementation
found here:
7ea4895513/crates/nu-protocol/src/errors/shell_error.rs (L1534-L1583)
which hid some downcasting from I/O errors and made it hard to trace
where `ShellError` was converted into `std::io::Error`. To address this,
I introduced a new struct called `ShellErrorBridge`, which explicitly
defines this transfer behavior. With `ShellErrorBridge`, we can now
easily grep the codebase to locate and manage such conversions.
## Miscellaneous
- Removed the OS error added in #14640, as it’s no longer needed.
- Improved error messages in `glob_from` (#14679).
- Trying to open a directory with `open` caused a permissions denied
error (it's just what the OS provides). I added a `is_dir` check to
provide a better error in that case.
# User-Facing Changes
<!-- List of all changes that impact the user experience here. This
helps us keep track of breaking changes. -->
- Error outputs now include more detailed information and are formatted
differently, including updated error codes.
- The structure of `ShellError` has changed, requiring plugin authors
and embedders to update their implementations.
# Tests + Formatting
<!--
Don't forget to add tests that cover your changes.
Make sure you've run and fixed any issues with these commands:
- `cargo fmt --all -- --check` to check standard code formatting (`cargo
fmt --all` applies these changes)
- `cargo clippy --workspace -- -D warnings -D clippy::unwrap_used` to
check that you're using the standard code style
- `cargo test --workspace` to check that all tests pass (on Windows make
sure to [enable developer
mode](https://learn.microsoft.com/en-us/windows/apps/get-started/developer-mode-features-and-debugging))
- `cargo run -- -c "use toolkit.nu; toolkit test stdlib"` to run the
tests for the standard library
> **Note**
> from `nushell` you can also use the `toolkit` as follows
> ```bash
> use toolkit.nu # or use an `env_change` hook to activate it
automatically
> toolkit check pr
> ```
-->
I updated tests to account for the new I/O error structure and
formatting changes.
# After Submitting
<!-- If your PR had any user-facing changes, update [the
documentation](https://github.com/nushell/nushell.github.io) after the
PR is merged, if necessary. This will help us keep the docs up to date.
-->
This PR closes #7695 and closes #14892 and partially addresses #4323 and
#10698.
---------
Co-authored-by: Darren Schroeder <343840+fdncred@users.noreply.github.com>
This commit is contained in:
Piepmatz
GitHub
@ -2,7 +2,8 @@ use std::ffi::OsStr;
|
||||
use std::io::{Stdin, Stdout};
|
||||
use std::process::{Child, ChildStdin, ChildStdout, Command, Stdio};
|
||||
|
||||
use nu_protocol::ShellError;
|
||||
use nu_protocol::shell_error::io::IoError;
|
||||
use nu_protocol::{ShellError, Span};
|
||||
|
||||
#[cfg(feature = "local-socket")]
|
||||
mod local_socket;
|
||||
@ -84,8 +85,15 @@ impl CommunicationMode {
|
||||
|
||||
let listener = interpret_local_socket_name(name)
|
||||
.and_then(|name| ListenerOptions::new().name(name).create_sync())
|
||||
.map_err(|err| ShellError::IOError {
|
||||
msg: format!("failed to open socket for plugin: {err}"),
|
||||
.map_err(|err| {
|
||||
IoError::new_internal(
|
||||
err.kind(),
|
||||
format!(
|
||||
"Could not interpret local socket name {:?}",
|
||||
name.to_string_lossy()
|
||||
),
|
||||
nu_protocol::location!(),
|
||||
)
|
||||
})?;
|
||||
Ok(PreparedServerCommunication::LocalSocket { listener })
|
||||
}
|
||||
@ -107,8 +115,15 @@ impl CommunicationMode {
|
||||
|
||||
interpret_local_socket_name(name)
|
||||
.and_then(|name| ls::Stream::connect(name))
|
||||
.map_err(|err| ShellError::IOError {
|
||||
msg: format!("failed to connect to socket: {err}"),
|
||||
.map_err(|err| {
|
||||
ShellError::Io(IoError::new_internal(
|
||||
err.kind(),
|
||||
format!(
|
||||
"Could not interpret local socket name {:?}",
|
||||
name.to_string_lossy()
|
||||
),
|
||||
nu_protocol::location!(),
|
||||
))
|
||||
})
|
||||
};
|
||||
// Reverse order from the server: read in, write out
|
||||
@ -171,7 +186,16 @@ impl PreparedServerCommunication {
|
||||
// output) and one for write (the plugin input)
|
||||
//
|
||||
// Be non-blocking on Accept only, so we can timeout.
|
||||
listener.set_nonblocking(ListenerNonblockingMode::Accept)?;
|
||||
listener
|
||||
.set_nonblocking(ListenerNonblockingMode::Accept)
|
||||
.map_err(|err| {
|
||||
IoError::new_with_additional_context(
|
||||
err.kind(),
|
||||
Span::unknown(),
|
||||
None,
|
||||
"Could not set non-blocking mode accept for listener",
|
||||
)
|
||||
})?;
|
||||
let mut get_socket = || {
|
||||
let mut result = None;
|
||||
while let Ok(None) = child.try_wait() {
|
||||
@ -179,7 +203,14 @@ impl PreparedServerCommunication {
|
||||
Ok(stream) => {
|
||||
// Success! Ensure the stream is in nonblocking mode though, for
|
||||
// good measure. Had an issue without this on macOS.
|
||||
stream.set_nonblocking(false)?;
|
||||
stream.set_nonblocking(false).map_err(|err| {
|
||||
IoError::new_with_additional_context(
|
||||
err.kind(),
|
||||
Span::unknown(),
|
||||
None,
|
||||
"Could not disable non-blocking mode for listener",
|
||||
)
|
||||
})?;
|
||||
result = Some(stream);
|
||||
break;
|
||||
}
|
||||
@ -187,7 +218,11 @@ impl PreparedServerCommunication {
|
||||
if !is_would_block_err(&err) {
|
||||
// `WouldBlock` is ok, just means it's not ready yet, but some other
|
||||
// kind of error should be reported
|
||||
return Err(err.into());
|
||||
return Err(ShellError::Io(IoError::new(
|
||||
err.kind(),
|
||||
Span::unknown(),
|
||||
None,
|
||||
)));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -2,8 +2,8 @@
|
||||
|
||||
use nu_plugin_protocol::{ByteStreamInfo, ListStreamInfo, PipelineDataHeader, StreamMessage};
|
||||
use nu_protocol::{
|
||||
engine::Sequence, ByteStream, IntoSpanned, ListStream, PipelineData, Reader, ShellError,
|
||||
Signals,
|
||||
engine::Sequence, shell_error::io::IoError, ByteStream, ListStream, PipelineData, Reader,
|
||||
ShellError, Signals, Span,
|
||||
};
|
||||
use std::{
|
||||
io::{Read, Write},
|
||||
@ -80,8 +80,12 @@ where
|
||||
}
|
||||
|
||||
fn flush(&self) -> Result<(), ShellError> {
|
||||
self.0.lock().flush().map_err(|err| ShellError::IOError {
|
||||
msg: err.to_string(),
|
||||
self.0.lock().flush().map_err(|err| {
|
||||
ShellError::Io(IoError::new_internal(
|
||||
err.kind(),
|
||||
"PluginWrite could not flush",
|
||||
nu_protocol::location!(),
|
||||
))
|
||||
})
|
||||
}
|
||||
|
||||
@ -106,8 +110,12 @@ where
|
||||
let mut lock = self.0.lock().map_err(|_| ShellError::NushellFailed {
|
||||
msg: "writer mutex poisoned".into(),
|
||||
})?;
|
||||
lock.flush().map_err(|err| ShellError::IOError {
|
||||
msg: err.to_string(),
|
||||
lock.flush().map_err(|err| {
|
||||
ShellError::Io(IoError::new_internal(
|
||||
err.kind(),
|
||||
"PluginWrite could not flush",
|
||||
nu_protocol::location!(),
|
||||
))
|
||||
})
|
||||
}
|
||||
}
|
||||
@ -332,7 +340,7 @@ where
|
||||
writer.write_all(std::iter::from_fn(move || match reader.read(buf) {
|
||||
Ok(0) => None,
|
||||
Ok(len) => Some(Ok(buf[..len].to_vec())),
|
||||
Err(err) => Some(Err(ShellError::from(err.into_spanned(span)))),
|
||||
Err(err) => Some(Err(ShellError::from(IoError::new(err.kind(), span, None)))),
|
||||
}))?;
|
||||
Ok(())
|
||||
}
|
||||
@ -357,6 +365,14 @@ where
|
||||
log::warn!("Error while writing pipeline in background: {err}");
|
||||
}
|
||||
result
|
||||
})
|
||||
.map_err(|err| {
|
||||
IoError::new_with_additional_context(
|
||||
err.kind(),
|
||||
Span::unknown(),
|
||||
None,
|
||||
"Could not spawn plugin stream background writer",
|
||||
)
|
||||
})?,
|
||||
)),
|
||||
}
|
||||
|
||||
@ -8,8 +8,8 @@ use nu_plugin_protocol::{
|
||||
StreamMessage,
|
||||
};
|
||||
use nu_protocol::{
|
||||
engine::Sequence, ByteStream, ByteStreamSource, ByteStreamType, DataSource, ListStream,
|
||||
PipelineData, PipelineMetadata, ShellError, Signals, Span, Value,
|
||||
engine::Sequence, shell_error::io::IoError, ByteStream, ByteStreamSource, ByteStreamType,
|
||||
DataSource, ListStream, PipelineData, PipelineMetadata, ShellError, Signals, Span, Value,
|
||||
};
|
||||
use std::{path::Path, sync::Arc};
|
||||
|
||||
@ -245,7 +245,8 @@ fn read_pipeline_data_byte_stream() -> Result<(), ShellError> {
|
||||
match stream.into_source() {
|
||||
ByteStreamSource::Read(mut read) => {
|
||||
let mut buf = Vec::new();
|
||||
read.read_to_end(&mut buf)?;
|
||||
read.read_to_end(&mut buf)
|
||||
.map_err(|err| IoError::new(err.kind(), test_span, None))?;
|
||||
let iter = buf.chunks_exact(out_pattern.len());
|
||||
assert_eq!(iter.len(), iterations);
|
||||
for chunk in iter {
|
||||
|
||||
@ -1,5 +1,5 @@
|
||||
use nu_plugin_protocol::{PluginInput, PluginOutput};
|
||||
use nu_protocol::ShellError;
|
||||
use nu_protocol::{location, shell_error::io::IoError, ShellError};
|
||||
use serde::Deserialize;
|
||||
|
||||
use crate::{Encoder, PluginEncoder};
|
||||
@ -26,8 +26,12 @@ impl Encoder<PluginInput> for JsonSerializer {
|
||||
writer: &mut impl std::io::Write,
|
||||
) -> Result<(), nu_protocol::ShellError> {
|
||||
serde_json::to_writer(&mut *writer, plugin_input).map_err(json_encode_err)?;
|
||||
writer.write_all(b"\n").map_err(|err| ShellError::IOError {
|
||||
msg: err.to_string(),
|
||||
writer.write_all(b"\n").map_err(|err| {
|
||||
ShellError::Io(IoError::new_internal(
|
||||
err.kind(),
|
||||
"Failed to write final line break",
|
||||
location!(),
|
||||
))
|
||||
})
|
||||
}
|
||||
|
||||
@ -49,8 +53,12 @@ impl Encoder<PluginOutput> for JsonSerializer {
|
||||
writer: &mut impl std::io::Write,
|
||||
) -> Result<(), ShellError> {
|
||||
serde_json::to_writer(&mut *writer, plugin_output).map_err(json_encode_err)?;
|
||||
writer.write_all(b"\n").map_err(|err| ShellError::IOError {
|
||||
msg: err.to_string(),
|
||||
writer.write_all(b"\n").map_err(|err| {
|
||||
ShellError::Io(IoError::new_internal(
|
||||
err.kind(),
|
||||
"JsonSerializer could not encode linebreak",
|
||||
nu_protocol::location!(),
|
||||
))
|
||||
})
|
||||
}
|
||||
|
||||
@ -68,9 +76,11 @@ impl Encoder<PluginOutput> for JsonSerializer {
|
||||
/// Handle a `serde_json` encode error.
|
||||
fn json_encode_err(err: serde_json::Error) -> ShellError {
|
||||
if err.is_io() {
|
||||
ShellError::IOError {
|
||||
msg: err.to_string(),
|
||||
}
|
||||
ShellError::Io(IoError::new_internal(
|
||||
err.io_error_kind().expect("is io"),
|
||||
"Could not encode with json",
|
||||
nu_protocol::location!(),
|
||||
))
|
||||
} else {
|
||||
ShellError::PluginFailedToEncode {
|
||||
msg: err.to_string(),
|
||||
@ -83,9 +93,11 @@ fn json_decode_err<T>(err: serde_json::Error) -> Result<Option<T>, ShellError> {
|
||||
if err.is_eof() {
|
||||
Ok(None)
|
||||
} else if err.is_io() {
|
||||
Err(ShellError::IOError {
|
||||
msg: err.to_string(),
|
||||
})
|
||||
Err(ShellError::Io(IoError::new_internal(
|
||||
err.io_error_kind().expect("is io"),
|
||||
"Could not decode with json",
|
||||
nu_protocol::location!(),
|
||||
)))
|
||||
} else {
|
||||
Err(ShellError::PluginFailedToDecode {
|
||||
msg: err.to_string(),
|
||||
|
||||
@ -1,7 +1,7 @@
|
||||
use std::io::ErrorKind;
|
||||
|
||||
use nu_plugin_protocol::{PluginInput, PluginOutput};
|
||||
use nu_protocol::ShellError;
|
||||
use nu_protocol::{shell_error::io::IoError, ShellError};
|
||||
use serde::Deserialize;
|
||||
|
||||
use crate::{Encoder, PluginEncoder};
|
||||
@ -64,9 +64,12 @@ fn rmp_encode_err(err: rmp_serde::encode::Error) -> ShellError {
|
||||
match err {
|
||||
rmp_serde::encode::Error::InvalidValueWrite(_) => {
|
||||
// I/O error
|
||||
ShellError::IOError {
|
||||
msg: err.to_string(),
|
||||
}
|
||||
ShellError::Io(IoError::new_internal(
|
||||
// TODO: get a better kind here
|
||||
std::io::ErrorKind::Other,
|
||||
"Could not encode with rmp",
|
||||
nu_protocol::location!(),
|
||||
))
|
||||
}
|
||||
_ => {
|
||||
// Something else
|
||||
@ -87,9 +90,12 @@ fn rmp_decode_err<T>(err: rmp_serde::decode::Error) -> Result<Option<T>, ShellEr
|
||||
Ok(None)
|
||||
} else {
|
||||
// I/O error
|
||||
Err(ShellError::IOError {
|
||||
msg: err.to_string(),
|
||||
})
|
||||
Err(ShellError::Io(IoError::new_internal(
|
||||
// TODO: get a better kind here
|
||||
std::io::ErrorKind::Other,
|
||||
"Could not decode with rmp",
|
||||
nu_protocol::location!(),
|
||||
)))
|
||||
}
|
||||
}
|
||||
_ => {
|
||||
|
||||
@ -36,18 +36,18 @@ macro_rules! generate_tests {
|
||||
let mut buffered = std::io::BufReader::new(ErrorProducer);
|
||||
match Encoder::<PluginInput>::decode(&encoder, &mut buffered) {
|
||||
Ok(_) => panic!("decode: i/o error was not passed through"),
|
||||
Err(ShellError::IOError { .. }) => (), // okay
|
||||
Err(ShellError::Io(_)) => (), // okay
|
||||
Err(other) => panic!(
|
||||
"decode: got other error, should have been a \
|
||||
ShellError::IOError: {other:?}"
|
||||
ShellError::Io: {other:?}"
|
||||
),
|
||||
}
|
||||
match Encoder::<PluginOutput>::decode(&encoder, &mut buffered) {
|
||||
Ok(_) => panic!("decode: i/o error was not passed through"),
|
||||
Err(ShellError::IOError { .. }) => (), // okay
|
||||
Err(ShellError::Io(_)) => (), // okay
|
||||
Err(other) => panic!(
|
||||
"decode: got other error, should have been a \
|
||||
ShellError::IOError: {other:?}"
|
||||
ShellError::Io: {other:?}"
|
||||
),
|
||||
}
|
||||
}
|
||||
@ -378,9 +378,11 @@ macro_rules! generate_tests {
|
||||
.with_url("https://example.org/test/error")
|
||||
.with_help("some help")
|
||||
.with_label("msg", Span::new(2, 30))
|
||||
.with_inner(ShellError::IOError {
|
||||
msg: "io error".into(),
|
||||
});
|
||||
.with_inner(ShellError::Io(IoError::new(
|
||||
std::io::ErrorKind::NotFound,
|
||||
Span::test_data(),
|
||||
None,
|
||||
)));
|
||||
|
||||
let response = PluginCallResponse::Error(error.clone());
|
||||
let output = PluginOutput::CallResponse(6, response);
|
||||
|
||||
Reference in New Issue
Block a user