| #![feature(future_join)] |
| #![feature(min_specialization)] |
| #![feature(arbitrary_self_types)] |
| #![feature(arbitrary_self_types_pointers)] |
|
|
| use std::{str::FromStr, time::Instant}; |
|
|
| use anyhow::{Context, Result}; |
| use futures_util::{StreamExt, TryStreamExt}; |
| use next_api::{ |
| project::{ProjectContainer, ProjectOptions}, |
| route::{Endpoint, EndpointOutputPaths, Route, endpoint_write_to_disk}, |
| }; |
| use turbo_rcstr::RcStr; |
| use turbo_tasks::{ReadConsistency, ResolvedVc, TransientInstance, TurboTasks, Vc, get_effects}; |
| use turbo_tasks_backend::{NoopBackingStorage, TurboTasksBackend}; |
| use turbo_tasks_malloc::TurboMalloc; |
|
|
| pub async fn main_inner( |
| tt: &TurboTasks<TurboTasksBackend<NoopBackingStorage>>, |
| strategy: Strategy, |
| factor: usize, |
| limit: usize, |
| files: Option<Vec<String>>, |
| ) -> Result<()> { |
| register(); |
|
|
| let path = std::env::current_dir()?.join("project_options.json"); |
| let mut file = std::fs::File::open(&path) |
| .with_context(|| format!("loading file at {}", path.display()))?; |
|
|
| let mut options: ProjectOptions = serde_json::from_reader(&mut file)?; |
|
|
| if matches!(strategy, Strategy::Development { .. }) { |
| options.dev = true; |
| options.watch.enable = true; |
| } else { |
| options.dev = false; |
| options.watch.enable = false; |
| } |
|
|
| let project = tt |
| .run_once(async { |
| let project = ProjectContainer::new("next-build-test".into(), options.dev); |
| let project = project.to_resolved().await?; |
| project.initialize(options).await?; |
| Ok(project) |
| }) |
| .await?; |
|
|
| tracing::info!("collecting endpoints"); |
| let entrypoints = tt |
| .run_once(async move { project.entrypoints().await }) |
| .await?; |
|
|
| let mut routes = if let Some(files) = files { |
| tracing::info!("building only the files:"); |
| for file in &files { |
| tracing::info!(" {}", file); |
| } |
|
|
| |
| |
| Box::new(files.into_iter().filter_map(|f| { |
| entrypoints |
| .routes |
| .iter() |
| .find(|(name, _)| f.as_str() == name.as_str()) |
| .map(|(name, route)| (name.clone(), route.clone())) |
| })) as Box<dyn Iterator<Item = _> + Send + Sync> |
| } else { |
| Box::new(entrypoints.routes.clone().into_iter()) |
| }; |
|
|
| if strategy.randomized() { |
| routes = Box::new(shuffle(routes)) |
| } |
|
|
| let start = Instant::now(); |
| let count = render_routes(tt, routes, strategy, factor, limit).await?; |
| tracing::info!("rendered {} pages in {:?}", count, start.elapsed()); |
|
|
| if count == 0 { |
| tracing::info!("No pages found, these pages exist:"); |
| for (route, _) in entrypoints.routes.iter() { |
| tracing::info!(" {}", route); |
| } |
| } |
|
|
| if matches!(strategy, Strategy::Development { .. }) { |
| hmr(tt, *project).await?; |
| } |
|
|
| Ok(()) |
| } |
|
|
| pub fn register() { |
| next_api::register(); |
| include!(concat!(env!("OUT_DIR"), "/register.rs")); |
| } |
|
|
| #[derive(PartialEq, Copy, Clone)] |
| pub enum Strategy { |
| Sequential { randomized: bool }, |
| Concurrent, |
| Parallel { randomized: bool }, |
| Development { randomized: bool }, |
| } |
|
|
| impl std::fmt::Display for Strategy { |
| fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { |
| match self { |
| Strategy::Sequential { randomized: false } => write!(f, "sequential"), |
| Strategy::Sequential { randomized: true } => write!(f, "sequential-randomized"), |
| Strategy::Concurrent => write!(f, "concurrent"), |
| Strategy::Parallel { randomized: false } => write!(f, "parallel"), |
| Strategy::Parallel { randomized: true } => write!(f, "parallel-randomized"), |
| Strategy::Development { randomized: false } => write!(f, "development"), |
| Strategy::Development { randomized: true } => write!(f, "development-randomized"), |
| } |
| } |
| } |
|
|
| impl FromStr for Strategy { |
| type Err = anyhow::Error; |
|
|
| fn from_str(s: &str) -> Result<Self> { |
| match s { |
| "sequential" => Ok(Strategy::Sequential { randomized: false }), |
| "sequential-randomized" => Ok(Strategy::Sequential { randomized: true }), |
| "concurrent" => Ok(Strategy::Concurrent), |
| "parallel" => Ok(Strategy::Parallel { randomized: false }), |
| "parallel-randomized" => Ok(Strategy::Parallel { randomized: true }), |
| "development" => Ok(Strategy::Development { randomized: false }), |
| "development-randomized" => Ok(Strategy::Development { randomized: true }), |
| _ => Err(anyhow::anyhow!("invalid strategy")), |
| } |
| } |
| } |
|
|
| impl Strategy { |
| pub fn randomized(&self) -> bool { |
| match self { |
| Strategy::Sequential { randomized } => *randomized, |
| Strategy::Concurrent => false, |
| Strategy::Parallel { randomized } => *randomized, |
| Strategy::Development { randomized } => *randomized, |
| } |
| } |
| } |
|
|
| pub fn shuffle<'a, T: 'a>(items: impl Iterator<Item = T>) -> impl Iterator<Item = T> { |
| use rand::{SeedableRng, seq::SliceRandom}; |
| let mut rng = rand::rngs::SmallRng::from_seed([0; 32]); |
| let mut input = items.collect::<Vec<_>>(); |
| input.shuffle(&mut rng); |
| input.into_iter() |
| } |
|
|
| pub async fn render_routes( |
| tt: &TurboTasks<TurboTasksBackend<NoopBackingStorage>>, |
| routes: impl Iterator<Item = (RcStr, Route)>, |
| strategy: Strategy, |
| factor: usize, |
| limit: usize, |
| ) -> Result<usize> { |
| tracing::info!( |
| "rendering routes with {} parallel and strategy {}", |
| factor, |
| strategy |
| ); |
|
|
| let stream = tokio_stream::iter(routes) |
| .map(move |(name, route)| async move { |
| tracing::info!("{name}..."); |
| let start = Instant::now(); |
|
|
| let memory = TurboMalloc::memory_usage(); |
|
|
| tt.run_once({ |
| let name = name.clone(); |
| async move { |
| match route { |
| Route::Page { |
| html_endpoint, |
| data_endpoint: _, |
| } => { |
| endpoint_write_to_disk_with_effects(*html_endpoint).await?; |
| } |
| Route::PageApi { endpoint } => { |
| endpoint_write_to_disk_with_effects(*endpoint).await?; |
| } |
| Route::AppPage(routes) => { |
| for route in routes { |
| endpoint_write_to_disk_with_effects(*route.html_endpoint).await?; |
| } |
| } |
| Route::AppRoute { |
| original_name: _, |
| endpoint, |
| } => { |
| endpoint_write_to_disk_with_effects(*endpoint).await?; |
| } |
| Route::Conflict => { |
| tracing::info!("WARN: conflict {}", name); |
| } |
| } |
| Ok(()) |
| } |
| }) |
| .await?; |
|
|
| let duration = start.elapsed(); |
| let memory_after = TurboMalloc::memory_usage(); |
| if matches!(strategy, Strategy::Sequential { .. }) { |
| if memory_after > memory { |
| tracing::info!( |
| "{name} {:?} {} MiB (memory usage increased by {} MiB)", |
| duration, |
| memory_after / 1024 / 1024, |
| (memory_after - memory) / 1024 / 1024 |
| ); |
| } else { |
| tracing::info!( |
| "{name} {:?} {} MiB (memory usage decreased by {} MiB)", |
| duration, |
| memory_after / 1024 / 1024, |
| (memory - memory_after) / 1024 / 1024 |
| ); |
| } |
| } else { |
| tracing::info!("{name} {:?} {} MiB", duration, memory_after / 1024 / 1024); |
| } |
|
|
| Ok::<_, anyhow::Error>(()) |
| }) |
| .take(limit) |
| .buffer_unordered(factor) |
| .try_collect::<Vec<_>>() |
| .await?; |
|
|
| Ok(stream.len()) |
| } |
|
|
| #[turbo_tasks::function] |
| async fn endpoint_write_to_disk_with_effects( |
| endpoint: ResolvedVc<Box<dyn Endpoint>>, |
| ) -> Result<Vc<EndpointOutputPaths>> { |
| let op = endpoint_write_to_disk_operation(endpoint); |
| let result = op.resolve_strongly_consistent().await?; |
| get_effects(op).await?.apply().await?; |
| Ok(*result) |
| } |
|
|
| #[turbo_tasks::function(operation)] |
| pub fn endpoint_write_to_disk_operation( |
| endpoint: ResolvedVc<Box<dyn Endpoint>>, |
| ) -> Vc<EndpointOutputPaths> { |
| endpoint_write_to_disk(*endpoint) |
| } |
|
|
| async fn hmr( |
| tt: &TurboTasks<TurboTasksBackend<NoopBackingStorage>>, |
| project: Vc<ProjectContainer>, |
| ) -> Result<()> { |
| tracing::info!("HMR..."); |
| let session = TransientInstance::new(()); |
| let idents = tt |
| .run_once(async move { project.hmr_identifiers().await }) |
| .await?; |
| let start = Instant::now(); |
| for ident in idents { |
| if !ident.ends_with(".js") { |
| continue; |
| } |
| let session = session.clone(); |
| let start = Instant::now(); |
| let task = tt.spawn_root_task(move || { |
| let session = session.clone(); |
| async move { |
| let project = project.project(); |
| let state = project.hmr_version_state(ident.clone(), session); |
| project.hmr_update(ident.clone(), state).await?; |
| Ok(Vc::<()>::cell(())) |
| } |
| }); |
| tt.wait_task_completion(task, ReadConsistency::Strong) |
| .await?; |
| let e = start.elapsed(); |
| if e.as_millis() > 10 { |
| tracing::info!("HMR: {:?} {:?}", ident, e); |
| } |
| } |
| tracing::info!("HMR {:?}", start.elapsed()); |
|
|
| Ok(()) |
| } |
|
|
