use anyhow::{Result, anyhow, bail}; use async_stream::try_stream as generator; use futures::{ SinkExt, StreamExt, TryStreamExt, channel::mpsc::{UnboundedSender, unbounded}, pin_mut, }; use parking_lot::Mutex; use serde::{Deserialize, Serialize}; use turbo_rcstr::{RcStr, rcstr}; use turbo_tasks::{ RawVc, ResolvedVc, TaskInput, ValueToString, Vc, VcValueType, duration_span, mark_finished, prevent_gc, trace::TraceRawVcs, util::SharedError, }; use turbo_tasks_bytes::{Bytes, Stream}; use turbo_tasks_env::ProcessEnv; use turbo_tasks_fs::FileSystemPath; use turbopack_core::{ chunk::{ChunkingContext, EvaluatableAsset, EvaluatableAssets}, error::PrettyPrintError, issue::{IssueExt, StyledString}, module::Module, }; use turbopack_dev_server::source::{Body, ProxyResult}; use super::{ RenderData, RenderProxyIncomingMessage, RenderProxyOutgoingMessage, ResponseHeaders, issue::RenderingIssue, }; use crate::{ get_intermediate_asset, get_renderer_pool_operation, pool::NodeJsOperation, render::error_page::error_html, source_map::trace_stack, }; /// Renders a module as static HTML in a node.js process. #[turbo_tasks::function(operation)] pub async fn render_proxy_operation( cwd: FileSystemPath, env: ResolvedVc>, path: FileSystemPath, module: ResolvedVc>, runtime_entries: ResolvedVc, chunking_context: ResolvedVc>, intermediate_output_path: FileSystemPath, output_root: FileSystemPath, project_dir: FileSystemPath, data: ResolvedVc, body: ResolvedVc, debug: bool, ) -> Result> { let render = render_stream(RenderStreamOptions { cwd, env, path, module, runtime_entries, chunking_context, intermediate_output_path, output_root, project_dir, data, body, debug, }) .await?; let mut stream = render.read(); let first = match stream.try_next().await? { Some(f) => f, None => { // If an Error was received first, then it would have been // transformed into a proxy err error response. bail!("did not receive response from render"); } }; let RenderItem::Headers(data) = first else { bail!("did not receive headers from render"); }; let body = Body::from_stream(stream.map(|item| match item { Ok(RenderItem::BodyChunk(b)) => Ok(b), Ok(v) => Err(SharedError::new(anyhow!( "unexpected render item: {:#?}", v ))), Err(e) => Err(e), })); let result = ProxyResult { status: data.status, headers: data.headers, body, }; Ok(result.cell()) } async fn proxy_error( path: FileSystemPath, error: anyhow::Error, operation: Option, ) -> Result<(u16, RcStr)> { let message = format!("{}", PrettyPrintError(&error)); let status = match operation { Some(operation) => Some(operation.wait_or_kill().await?), None => None, }; let mut details = vec![]; if let Some(status) = status { details.push(format!("status: {status}")); } let status_code = 500; let body = error_html( status_code, rcstr!("An error occurred while proxying the request to Node.js"), format!("{message}\n\n{}", details.join("\n")).into(), ) .owned() .await?; RenderingIssue { file_path: path, message: StyledString::Text(message.into()).resolved_cell(), status: status.and_then(|status| status.code()), } .resolved_cell() .emit(); Ok((status_code, body)) } #[derive(Clone, Debug)] #[turbo_tasks::value] enum RenderItem { Headers(ResponseHeaders), BodyChunk(Bytes), } type RenderItemResult = Result; #[turbo_tasks::value(eq = "manual", cell = "new", serialization = "none")] struct RenderStreamSender { #[turbo_tasks(trace_ignore, debug_ignore)] get: Box UnboundedSender + Send + Sync>, } #[turbo_tasks::value(transparent)] struct RenderStream(#[turbo_tasks(trace_ignore)] Stream); #[derive(Clone, Debug, TaskInput, PartialEq, Eq, Hash, Serialize, Deserialize, TraceRawVcs)] struct RenderStreamOptions { cwd: FileSystemPath, env: ResolvedVc>, path: FileSystemPath, module: ResolvedVc>, runtime_entries: ResolvedVc, chunking_context: ResolvedVc>, intermediate_output_path: FileSystemPath, output_root: FileSystemPath, project_dir: FileSystemPath, data: ResolvedVc, body: ResolvedVc, debug: bool, } #[turbo_tasks::function] fn render_stream(options: RenderStreamOptions) -> Vc { // TODO: The way we invoke render_stream_internal as side effect is not // GC-safe, so we disable GC for this task. prevent_gc(); // Note the following code uses some hacks to create a child task that produces // a stream that is returned by this task. // We create a new cell in this task, which will be updated from the // [render_stream_internal] task. let cell = turbo_tasks::macro_helpers::find_cell_by_type( ::get_value_type_id(), ); // We initialize the cell with a stream that is open, but has no values. // The first [render_stream_internal] pipe call will pick up that stream. let (sender, receiver) = unbounded(); cell.update(RenderStream(Stream::new_open(vec![], Box::new(receiver)))); let initial = Mutex::new(Some(sender)); // run the evaluation as side effect let _ = render_stream_internal( options, RenderStreamSender { get: Box::new(move || { if let Some(sender) = initial.lock().take() { sender } else { // In cases when only [render_stream_internal] is (re)executed, we need to // update the old stream with a new value. let (sender, receiver) = unbounded(); cell.update(RenderStream(Stream::new_open(vec![], Box::new(receiver)))); sender } }), } .cell(), ); let raw: RawVc = cell.into(); raw.into() } #[turbo_tasks::function] async fn render_stream_internal( options: RenderStreamOptions, sender: Vc, ) -> Result> { let RenderStreamOptions { cwd, env, path, module, runtime_entries, chunking_context, intermediate_output_path, output_root, project_dir, data, body, debug, } = options; mark_finished(); let Ok(sender) = sender.await else { // Impossible to handle the error in a good way. return Ok(Default::default()); }; let stream = generator! { let intermediate_asset = get_intermediate_asset( *chunking_context, *module, *runtime_entries, ).to_resolved().await?; let pool_op = get_renderer_pool_operation( cwd, env, intermediate_asset, intermediate_output_path.clone(), output_root, project_dir.clone(), debug, ); // Read this strongly consistent, since we don't want to run inconsistent // node.js code. let pool = pool_op.read_strongly_consistent().await?; let data = data.await?; let mut operation = pool.operation().await?; // First, send the render data. operation .send(RenderProxyOutgoingMessage::Headers { data: &data }) .await?; // Then, send the binary body in chunks. let mut body = body.await?.read(); while let Some(data) = body.next().await { operation .send(RenderProxyOutgoingMessage::BodyChunk { data: &data.unwrap() }) .await?; } operation.send(RenderProxyOutgoingMessage::BodyEnd).await?; let entry = module.ident().to_string().await?; let guard = duration_span!("Node.js api execution", entry = display(entry)); match operation.recv().await? { RenderProxyIncomingMessage::Headers { data } => yield RenderItem::Headers(data), RenderProxyIncomingMessage::Error(error) => { drop(guard); // If we don't get headers, then something is very wrong. Instead, we send down a // 500 proxy error as if it were the proper result. let trace = trace_stack( error, *intermediate_asset, intermediate_output_path.clone(), project_dir.clone() ) .await?; let (status, body) = proxy_error(path, anyhow!("error rendering: {}", trace), Some(operation)).await?; yield RenderItem::Headers(ResponseHeaders { status, headers: vec![( rcstr!("content-type"), rcstr!("text/html; charset=utf-8"), )], }); yield RenderItem::BodyChunk(body.into_owned().into_bytes().into()); return; } v => { drop(guard); Err(anyhow!("unexpected message during rendering: {:#?}", v))?; return; }, }; loop { match operation.recv().await? { RenderProxyIncomingMessage::BodyChunk { data } => { yield RenderItem::BodyChunk(data.into()); } RenderProxyIncomingMessage::BodyEnd => break, RenderProxyIncomingMessage::Error(error) => { drop(guard); // We have already started to send a result, so we can't change the // headers/body to a proxy error. operation.disallow_reuse(); let trace = trace_stack(error, *intermediate_asset, intermediate_output_path.clone(), project_dir.clone()).await?; Err(anyhow!("error during streaming render: {}", trace))?; return; } v => { drop(guard); Err(anyhow!("unexpected message during rendering: {:#?}", v))?; return; }, } } drop(guard); }; let mut sender = (sender.get)(); pin_mut!(stream); while let Some(value) = stream.next().await { if sender.send(value).await.is_err() { return Ok(Default::default()); } if sender.flush().await.is_err() { return Ok(Default::default()); } } Ok(Default::default()) }