Fix deadlock on PluginCustomValue drop (#12418)

# Description
Because the plugin interface reader thread can be responsible for
sending a drop notification, it's possible for it to end up in a
deadlock where it's waiting for the response to the drop notification
call.

I decided that the best way to address this is to just discard the
response and not wait for it. It's not really important to synchronize
with the response to `Dropped`, so this is probably faster anyway.

cc @ayax79, this is your issue where polars is getting stuck

# User-Facing Changes
- A bug fix
- Custom value plugin: `custom-value handle update` command

# Tests + Formatting

Tried to add a test with a long pipeline with a lot of drops and run it
over and over to reproduce the deadlock.

- 🟢 `toolkit fmt`
- 🟢 `toolkit clippy`
- 🟢 `toolkit test`
- 🟢 `toolkit test stdlib`
This commit is contained in:
Devyn Cairns
2024-04-05 19:57:00 -07:00
committed by GitHub
parent 82b7548c0c
commit c82dfce246
5 changed files with 141 additions and 11 deletions

View File

@ -0,0 +1,90 @@
use std::sync::atomic;
use nu_plugin::{EngineInterface, EvaluatedCall, SimplePluginCommand};
use nu_protocol::{
engine::Closure, LabeledError, ShellError, Signature, Spanned, SyntaxShape, Type, Value,
};
use crate::{handle_custom_value::HandleCustomValue, CustomValuePlugin};
pub struct HandleUpdate;
impl SimplePluginCommand for HandleUpdate {
type Plugin = CustomValuePlugin;
fn name(&self) -> &str {
"custom-value handle update"
}
fn signature(&self) -> Signature {
Signature::build(self.name())
.input_output_type(
Type::Custom("HandleCustomValue".into()),
Type::Custom("HandleCustomValue".into()),
)
.required(
"closure",
SyntaxShape::Closure(Some(vec![SyntaxShape::Any])),
"the closure to run on the value",
)
}
fn usage(&self) -> &str {
"Update the value in a handle and return a new handle with the result"
}
fn run(
&self,
plugin: &Self::Plugin,
engine: &EngineInterface,
call: &EvaluatedCall,
input: &Value,
) -> Result<Value, LabeledError> {
let closure: Spanned<Closure> = call.req(0)?;
if let Some(handle) = input
.as_custom_value()?
.as_any()
.downcast_ref::<HandleCustomValue>()
{
// Find the handle
let value = plugin
.handles
.lock()
.map_err(|err| LabeledError::new(err.to_string()))?
.get(&handle.0)
.cloned();
if let Some(value) = value {
// Call the closure with the value
let new_value = engine.eval_closure(&closure, vec![value.clone()], Some(value))?;
// Generate an id and store in the plugin.
let new_id = plugin.counter.fetch_add(1, atomic::Ordering::Relaxed);
plugin
.handles
.lock()
.map_err(|err| LabeledError::new(err.to_string()))?
.insert(new_id, new_value);
Ok(Value::custom(
Box::new(HandleCustomValue(new_id)),
call.head,
))
} else {
Err(LabeledError::new("Handle expired")
.with_label("this handle is no longer valid", input.span())
.with_help("the plugin may have exited, or there was a bug"))
}
} else {
Err(ShellError::UnsupportedInput {
msg: "requires HandleCustomValue".into(),
input: format!("got {}", input.get_type()),
msg_span: call.head,
input_span: input.span(),
}
.into())
}
}
}

View File

@ -15,6 +15,7 @@ mod generate;
mod generate2;
mod handle_get;
mod handle_make;
mod handle_update;
mod update;
mod update_arg;
@ -23,6 +24,7 @@ use generate::Generate;
use generate2::Generate2;
use handle_get::HandleGet;
use handle_make::HandleMake;
use handle_update::HandleUpdate;
use nu_protocol::{CustomValue, LabeledError, Spanned, Value};
use update::Update;
use update_arg::UpdateArg;
@ -49,6 +51,7 @@ impl Plugin for CustomValuePlugin {
Box::new(DropCheck),
Box::new(HandleGet),
Box::new(HandleMake),
Box::new(HandleUpdate),
]
}