holm/nushell
1
1
Fork 0
forked from extern/nushell
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Avoid blocking when o+e> redirects too much stderr message (#8784)

Browse Source 
# Description

Fixes: #8565

Here is another pr #7240 tried to address the issue, but it works in a
wrong way.

After this change `o+e>` won't redirect all stdout message then stderr
message and it works more like how bash does.

# User-Facing Changes

For the given python code:
```python
# test.py
import sys

print('aa'*300, flush=True)
print('bb'*999999, file=sys.stderr, flush=True)
print('cc'*300, flush=True)
```

Running `python test.py out+err> a.txt` shoudn't hang nushell, and
`a.txt` keeps output in the same order

## About the change
The core idea is that when doing lite-parsing, introduce a new variant
`LiteElement::SameTargetRedirection` if we meet `out+err>` redirection
token(which is generated by lex function),

During converting from lite block to block,
LiteElement::SameTargetRedirection will be converted to
PipelineElement::SameTargetRedirection.

Then in the block eval process, if we get
PipelineElement::SameTargetRedirection, we'll invoke `run-external` with
`--redirect-combine` flag, then pipe the result into save command

## What happened internally?

Take the following command as example:
`^ls o+e> log.txt`

lex parsing result(`Tokens`) are not changed, but `LiteBlock` and
`Block` is changed after this pr.
### LiteBlock before
```rust
LiteBlock {
    block: [
        LitePipeline { commands: [
            Command(None, LiteCommand { comments: [], parts: [Span { start: 39041, end: 39044 }] }),
            // actually the span of first Redirection is wrong too..
            Redirection(Span { start: 39058, end: 39062 }, StdoutAndStderr, LiteCommand { comments: [], parts: [Span { start: 39050, end: 39057 }] }),
        ]
    }]
}
```
### LiteBlock after
```rust
LiteBlock { 
    block: [
        LitePipeline {
            commands: [
                SameTargetRedirection {
                    cmd: (None, LiteCommand { comments: [], parts: [Span { start: 147945, end: 147948}]}),
                    redirection: (Span { start: 147949, end: 147957 }, LiteCommand { comments: [], parts: [Span { start: 147958, end: 147965 }]})
                }
            ]
        }
    ]
}
```
### Block before
```rust
Pipeline {
    elements: [
        Expression(None, Expression {
            expr: ExternalCall(Expression { expr: String("ls"), span: Span { start: 39042, end: 39044 }, ty: String, custom_completion: None }, [], false),
            span: Span { start: 39041, end: 39044 },
            ty: Any, custom_completion: None 
        }),
        Redirection(Span { start: 39058, end: 39062 }, StdoutAndStderr, Expression { expr: String("out.txt"), span: Span { start: 39050, end: 39057 }, ty: String, custom_completion: None })] }
```
### Block after
```rust
Pipeline {
    elements: [
        SameTargetRedirection { 
            cmd: (None, Expression {
                expr: ExternalCall(Expression { expr: String("ls"), span: Span { start: 147946, end: 147948 }, ty: String, custom_completion: None}, [], false),
                span: Span { start: 147945, end: 147948},
                ty: Any, custom_completion: None
            }),
            redirection: (Span { start: 147949, end: 147957}, Expression {expr: String("log.txt"), span: Span { start: 147958, end: 147965 },ty: String,custom_completion: None}
        }
    ]
}
```

# 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 -A
clippy::needless_collect` to check that you're using the standard code
style
- `cargo test --workspace` to check that all tests pass
- `cargo run -- crates/nu-utils/standard_library/tests.nu` 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
> ```

# 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 commit is contained in:
WindSoilder
2023-05-18 06:47:03 +08:00
committed by GitHub
parent 9c435fee75
commit b150f9f5d8
10 changed files with 265 additions and 75 deletions
Download Patch File Download Diff File Expand all files Collapse all files

140
crates/nu-engine/src/eval.rs
View File

@ -191,6 +191,11 @@ pub fn redirect_env(engine_state: &EngineState, caller_stack: &mut Stack, callee
}
}
enum RedirectTarget {
Piped(bool, bool),
CombinedPipe,
}
#[allow(clippy::too_many_arguments)]
fn eval_external(
engine_state: &EngineState,
@ -198,8 +203,7 @@ fn eval_external(
head: &Expression,
args: &[Expression],
input: PipelineData,
redirect_stdout: bool,
redirect_stderr: bool,
redirect_target: RedirectTarget,
is_subexpression: bool,
) -> Result<PipelineData, ShellError> {
let decl_id = engine_state
@ -216,26 +220,38 @@ fn eval_external(
call.add_positional(arg.clone())
}
if redirect_stdout {
call.add_named((
Spanned {
item: "redirect-stdout".into(),
span: head.span,
},
None,
None,
))
}
match redirect_target {
RedirectTarget::Piped(redirect_stdout, redirect_stderr) => {
if redirect_stdout {
call.add_named((
Spanned {
item: "redirect-stdout".into(),
span: head.span,
},
None,
None,
))
}
if redirect_stderr {
call.add_named((
if redirect_stderr {
call.add_named((
Spanned {
item: "redirect-stderr".into(),
span: head.span,
},
None,
None,
))
}
}
RedirectTarget::CombinedPipe => call.add_named((
Spanned {
item: "redirect-stderr".into(),
item: "redirect-combine".into(),
span: head.span,
},
None,
None,
))
)),
}
if is_subexpression {
@ -332,8 +348,7 @@ pub fn eval_expression(
head,
args,
PipelineData::empty(),
false,
false,
RedirectTarget::Piped(false, false),
*is_subexpression,
)?
.into_value(span))
@ -698,8 +713,7 @@ pub fn eval_expression_with_input(
head,
args,
input,
redirect_stdout,
redirect_stderr,
RedirectTarget::Piped(redirect_stdout, redirect_stderr),
*is_subexpression,
)?;
}
@ -792,50 +806,6 @@ pub fn eval_element_with_input(
metadata,
trim_end_newline,
},
(
Redirection::StdoutAndStderr,
PipelineData::ExternalStream {
stdout,
stderr,
exit_code,
span,
metadata,
trim_end_newline,
},
) => match (stdout, stderr) {
(Some(stdout), Some(stderr)) => PipelineData::ExternalStream {
stdout: Some(stdout.chain(stderr)),
stderr: None,
exit_code,
span,
metadata,
trim_end_newline,
},
(None, Some(stderr)) => PipelineData::ExternalStream {
stdout: Some(stderr),
stderr: None,
exit_code,
span,
metadata,
trim_end_newline,
},
(Some(stdout), None) => PipelineData::ExternalStream {
stdout: Some(stdout),
stderr: None,
exit_code,
span,
metadata,
trim_end_newline,
},
(None, None) => PipelineData::ExternalStream {
stdout: None,
stderr: None,
exit_code,
span,
metadata,
trim_end_newline,
},
},
(_, input) => input,
};
@ -970,6 +940,48 @@ pub fn eval_element_with_input(
}
}
},
PipelineElement::SameTargetRedirection {
cmd: (cmd_span, cmd_exp),
redirection: (redirect_span, redirect_exp),
} => {
// general idea: eval cmd and call save command to redirect stdout to result.
input = match &cmd_exp.expr {
Expr::ExternalCall(head, args, is_subexpression) => {
// if cmd's expression is ExternalStream, then invoke run-external with
// special --redirect-combine flag.
eval_external(
engine_state,
stack,
head,
args,
input,
RedirectTarget::CombinedPipe,
*is_subexpression,
)?
}
_ => eval_element_with_input(
engine_state,
stack,
&PipelineElement::Expression(*cmd_span, cmd_exp.clone()),
input,
redirect_stdout,
redirect_stderr,
)
.map(|x| x.0)?,
};
eval_element_with_input(
engine_state,
stack,
&PipelineElement::Redirection(
*redirect_span,
Redirection::Stdout,
redirect_exp.clone(),
),
input,
redirect_stdout,
redirect_stderr,
)
}
PipelineElement::And(_, expr) => eval_expression_with_input(
engine_state,
stack,