Upload folder using huggingface_hub

1e92f2d verified 8 months ago

11.2 kB

	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<Box<dyn ProcessEnv>>,
	path: FileSystemPath,
	module: ResolvedVc<Box<dyn EvaluatableAsset>>,
	runtime_entries: ResolvedVc<EvaluatableAssets>,
	chunking_context: ResolvedVc<Box<dyn ChunkingContext>>,
	intermediate_output_path: FileSystemPath,
	output_root: FileSystemPath,
	project_dir: FileSystemPath,
	data: ResolvedVc<RenderData>,
	body: ResolvedVc<Body>,
	debug: bool,
	) -> Result<Vc<ProxyResult>> {
	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<NodeJsOperation>,
	) -> 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<RenderItem, SharedError>;

	#[turbo_tasks::value(eq = "manual", cell = "new", serialization = "none")]
	struct RenderStreamSender {
	#[turbo_tasks(trace_ignore, debug_ignore)]
	get: Box<dyn Fn() -> UnboundedSender<RenderItemResult> + Send + Sync>,
	}

	#[turbo_tasks::value(transparent)]
	struct RenderStream(#[turbo_tasks(trace_ignore)] Stream<RenderItemResult>);

	#[derive(Clone, Debug, TaskInput, PartialEq, Eq, Hash, Serialize, Deserialize, TraceRawVcs)]
	struct RenderStreamOptions {
	cwd: FileSystemPath,
	env: ResolvedVc<Box<dyn ProcessEnv>>,
	path: FileSystemPath,
	module: ResolvedVc<Box<dyn EvaluatableAsset>>,
	runtime_entries: ResolvedVc<EvaluatableAssets>,
	chunking_context: ResolvedVc<Box<dyn ChunkingContext>>,
	intermediate_output_path: FileSystemPath,
	output_root: FileSystemPath,
	project_dir: FileSystemPath,
	data: ResolvedVc<RenderData>,
	body: ResolvedVc<Body>,
	debug: bool,
	}

	#[turbo_tasks::function]
	fn render_stream(options: RenderStreamOptions) -> Vc<RenderStream> {
	// 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(
	<RenderStream as VcValueType>::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<RenderStreamSender>,
	) -> Result<Vc<()>> {
	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())
	}