mirror of
https://github.com/hanzoai/next.js.git
synced 2026-10-30 14:46:38 +00:00
5d0dab5fc6
### What? Replaces the silent "make root node" promotion in the turbo-tasks backend with a panic that enforces tasks to already have the `root` attribute before performing strongly consistent reads, reading task collectibles, or removing collectibles. ### Why? Previously, the backend would silently promote any non-root task to a root node (aggregation number `u32::MAX`) when these operations were requested. This masked incorrect task configuration — tasks that needed root-level aggregation weren't explicitly declared as such, making it harder to reason about the aggregation graph and hiding potential performance issues from implicit promotions. ### How? **Backend enforcement (3 locations):** - **Strongly consistent read** (`backend/mod.rs`): Checks `NativeFunction.is_root` on the target task. If it's a persistent task without `root`, panics with both the target and reader task descriptions. - **Read task collectibles** (`backend/mod.rs`): Same check when reading collectibles from a task. - **Remove collectibles** (`operation/update_collectible.rs`): Same check when removing collectibles (count < 0). All three locations drop the task guard before panicking to avoid deadlocking with `debug_get_task_description`. **Macro support for `root` on methods:** - `value_impl_macro.rs`: Now reads the `root` attribute from `#[turbo_tasks::function(root)]` on inherent impl and trait impl methods (previously hardcoded to `false`). - `value_trait_macro.rs`: Same for trait default methods. **`root` attribute additions:** - All `#[turbo_tasks::function(operation)]` in test files, benchmarks, and fuzz code - Production operations in `crates/next-api/` that are read with strong consistency - Regular functions and methods in tests that use `.strongly_consistent()` - Trait methods in `value_impl` and `value_trait` blocks used with strong consistency **New test:** - `non_root_task_panic.rs`: Verifies the panic fires when attempting a strongly consistent read on a non-root operation task. Captures the panic from the worker thread via a panic hook since the panic propagates as a channel error to the test thread. <!-- NEXT_JS_LLM_PR --> --------- Co-authored-by: Claude Opus 4.7 (1M context) <[email protected]>
109 lines
3.4 KiB
Rust
109 lines
3.4 KiB
Rust
#![feature(arbitrary_self_types)]
|
|
#![feature(arbitrary_self_types_pointers)]
|
|
#![allow(clippy::needless_return)] // tokio macro-generated code doesn't respect this
|
|
|
|
use std::time::Duration;
|
|
|
|
use anyhow::{Result, bail};
|
|
use turbo_rcstr::RcStr;
|
|
use turbo_tasks::{CollectiblesSource, ReadRef, ResolvedVc, State, ValueToString, Vc, emit};
|
|
use turbo_tasks_testing::{Registration, register, run_once};
|
|
|
|
static REGISTRATION: Registration = register!();
|
|
|
|
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
|
async fn test_dirty_in_progress() {
|
|
run_once(®ISTRATION, || async {
|
|
let cases = [
|
|
(1, 3, 2, 2, ""),
|
|
(11, 13, 12, 42, "12"),
|
|
(1, 13, 11, 42, "11"),
|
|
(1, 3, 11, 42, "11"),
|
|
(11, 3, 2, 2, ""),
|
|
(11, 13, 2, 2, ""),
|
|
];
|
|
for (a, b, c, value, collectible) in cases {
|
|
println!("{a} -> {b} -> {c} = {value} {collectible}");
|
|
let input_val = ReadRef::new_owned(ChangingInput {
|
|
state: State::new(a),
|
|
});
|
|
let input_vc = ReadRef::resolved_cell(input_val.clone());
|
|
let output_op = compute_operation(input_vc);
|
|
output_op.read_strongly_consistent().await?;
|
|
println!("update to {b}");
|
|
input_val.state.set(b);
|
|
tokio::time::sleep(Duration::from_millis(50)).await;
|
|
println!("update to {c}");
|
|
input_val.state.set(c);
|
|
let read = output_op.read_strongly_consistent().await?;
|
|
assert_eq!(read.value, value);
|
|
assert_eq!(read.collectible, collectible);
|
|
println!("\n");
|
|
}
|
|
Ok(())
|
|
})
|
|
.await
|
|
.unwrap()
|
|
}
|
|
|
|
#[turbo_tasks::value]
|
|
struct ChangingInput {
|
|
state: State<u32>,
|
|
}
|
|
|
|
#[turbo_tasks::value]
|
|
struct Output {
|
|
value: u32,
|
|
collectible: String,
|
|
}
|
|
|
|
#[turbo_tasks::value]
|
|
struct Collectible {
|
|
value: u32,
|
|
}
|
|
|
|
#[turbo_tasks::value_impl]
|
|
impl ValueToString for Collectible {
|
|
#[turbo_tasks::function]
|
|
fn to_string(&self) -> Vc<RcStr> {
|
|
Vc::cell(self.value.to_string().into())
|
|
}
|
|
}
|
|
|
|
#[turbo_tasks::function(operation, root)]
|
|
async fn inner_compute(input: ResolvedVc<ChangingInput>) -> Result<Vc<u32>> {
|
|
println!("start inner_compute");
|
|
let value = *input.await?.state.get();
|
|
tokio::time::sleep(Duration::from_millis(200)).await;
|
|
if value > 10 {
|
|
let collectible: ResolvedVc<Box<dyn ValueToString>> =
|
|
ResolvedVc::upcast(Collectible { value }.resolved_cell());
|
|
emit(collectible);
|
|
|
|
println!("end inner_compute with collectible");
|
|
Ok(Vc::cell(42))
|
|
} else {
|
|
println!("end inner_compute without collectible");
|
|
Ok(Vc::cell(value))
|
|
}
|
|
}
|
|
|
|
#[turbo_tasks::function(operation, root)]
|
|
async fn compute_operation(input: ResolvedVc<ChangingInput>) -> Result<Vc<Output>> {
|
|
println!("start compute");
|
|
let operation = inner_compute(input);
|
|
let value = *operation.connect().await?;
|
|
let collectibles = operation.peek_collectibles::<Box<dyn ValueToString>>();
|
|
if collectibles.len() > 1 {
|
|
bail!("expected 0..1 collectible, found {}", collectibles.len());
|
|
}
|
|
let first = collectibles.iter().next();
|
|
let collectible = if let Some(first) = first {
|
|
first.to_string().await?.to_string()
|
|
} else {
|
|
"".to_string()
|
|
};
|
|
println!("end compute");
|
|
Ok(Output { value, collectible }.cell())
|
|
}
|