Unverified Commit f57eecde authored by JJ Kasper's avatar JJ Kasper Committed by GitHub

Separate routing code from render servers (#52492)

This breaks out routing handling from `next-server`, `next-dev-server`,
and `base-server` so that these are only handling the "render" work and
eventually these will be deleted completely in favor of the bundling
work being done.

The `router` process and separate `render` processes are still
maintained here although will be investigated further in follow-up to
see if we can reduce the need for these.

We are also changing the `require-cache` IPC to a single call instead of
call per entry to reduce overhead and also de-dupes handling for
starting the server between the standalone server and normal server.

To maintain support for existing turbopack route resolving this
implements the new route resolving in place of the existing
`route-resolver` until the new nextturbo API is fully landed.

After these initial changes we should continue to eliminate non-render
related code from `next-server`, `base-server`, and `next-dev-server`.
parent 04ae5be8
......@@ -17,7 +17,6 @@ import os from 'os'
import { Worker } from '../lib/worker'
import { defaultConfig } from '../server/config-shared'
import devalue from 'next/dist/compiled/devalue'
import { escapeStringRegexp } from '../shared/lib/escape-regexp'
import findUp from 'next/dist/compiled/find-up'
import { nanoid } from 'next/dist/compiled/nanoid/index.cjs'
import { pathToRegexp } from 'next/dist/compiled/path-to-regexp'
......@@ -141,7 +140,12 @@ import { createClientRouterFilter } from '../lib/create-client-router-filter'
import { createValidFileMatcher } from '../server/lib/find-page-file'
import { startTypeChecking } from './type-check'
import { generateInterceptionRoutesRewrites } from '../lib/generate-interception-routes-rewrites'
import { baseOverrides, experimentalOverrides } from '../server/require-hook'
import { buildDataRoute } from '../server/lib/router-utils/build-data-route'
import {
baseOverrides,
defaultOverrides,
experimentalOverrides,
} from '../server/require-hook'
export type SsgRoute = {
initialRevalidateSeconds: number | false
......@@ -166,6 +170,66 @@ export type PrerenderManifest = {
preview: __ApiPreviewProps
}
type CustomRoute = {
regex: string
statusCode?: number | undefined
permanent?: undefined
source: string
locale?: false | undefined
basePath?: false | undefined
destination?: string | undefined
}
export type RoutesManifest = {
version: number
pages404: boolean
basePath: string
redirects: Array<CustomRoute>
rewrites?:
| Array<CustomRoute>
| {
beforeFiles: Array<CustomRoute>
afterFiles: Array<CustomRoute>
fallback: Array<CustomRoute>
}
headers: Array<CustomRoute>
staticRoutes: Array<{
page: string
regex: string
namedRegex?: string
routeKeys?: { [key: string]: string }
}>
dynamicRoutes: Array<{
page: string
regex: string
namedRegex?: string
routeKeys?: { [key: string]: string }
}>
dataRoutes: Array<{
page: string
routeKeys?: { [key: string]: string }
dataRouteRegex: string
namedDataRouteRegex?: string
}>
i18n?: {
domains?: Array<{
http?: true
domain: string
locales?: string[]
defaultLocale: string
}>
locales: string[]
defaultLocale: string
localeDetection?: false
}
rsc: {
header: typeof RSC
varyHeader: typeof RSC_VARY_HEADER
}
skipMiddlewareUrlNormalize?: boolean
caseSensitive?: boolean
}
async function generateClientSsgManifest(
prerenderManifest: PrerenderManifest,
{
......@@ -684,89 +748,45 @@ export default async function build(
}
const routesManifestPath = path.join(distDir, ROUTES_MANIFEST)
const routesManifest: {
version: number
pages404: boolean
basePath: string
redirects: Array<ReturnType<typeof buildCustomRoute>>
rewrites?:
| Array<ReturnType<typeof buildCustomRoute>>
| {
beforeFiles: Array<ReturnType<typeof buildCustomRoute>>
afterFiles: Array<ReturnType<typeof buildCustomRoute>>
fallback: Array<ReturnType<typeof buildCustomRoute>>
const routesManifest: RoutesManifest = nextBuildSpan
.traceChild('generate-routes-manifest')
.traceFn(() => {
const sortedRoutes = getSortedRoutes([
...pageKeys.pages,
...(pageKeys.app ?? []),
])
const dynamicRoutes: Array<ReturnType<typeof pageToRoute>> = []
const staticRoutes: typeof dynamicRoutes = []
for (const route of sortedRoutes) {
if (isDynamicRoute(route)) {
dynamicRoutes.push(pageToRoute(route))
} else if (!isReservedPage(route)) {
staticRoutes.push(pageToRoute(route))
}
headers: Array<ReturnType<typeof buildCustomRoute>>
staticRoutes: Array<{
page: string
regex: string
namedRegex?: string
routeKeys?: { [key: string]: string }
}>
dynamicRoutes: Array<{
page: string
regex: string
namedRegex?: string
routeKeys?: { [key: string]: string }
}>
dataRoutes: Array<{
page: string
routeKeys?: { [key: string]: string }
dataRouteRegex: string
namedDataRouteRegex?: string
}>
i18n?: {
domains?: Array<{
http?: true
domain: string
locales?: string[]
defaultLocale: string
}>
locales: string[]
defaultLocale: string
localeDetection?: false
}
rsc: {
header: typeof RSC
varyHeader: typeof RSC_VARY_HEADER
}
skipMiddlewareUrlNormalize?: boolean
caseSensitive?: boolean
} = nextBuildSpan.traceChild('generate-routes-manifest').traceFn(() => {
const sortedRoutes = getSortedRoutes([
...pageKeys.pages,
...(pageKeys.app ?? []),
])
const dynamicRoutes: Array<ReturnType<typeof pageToRoute>> = []
const staticRoutes: typeof dynamicRoutes = []
for (const route of sortedRoutes) {
if (isDynamicRoute(route)) {
dynamicRoutes.push(pageToRoute(route))
} else if (!isReservedPage(route)) {
staticRoutes.push(pageToRoute(route))
}
}
return {
version: 3,
pages404: true,
caseSensitive: !!config.experimental.caseSensitiveRoutes,
basePath: config.basePath,
redirects: redirects.map((r: any) => buildCustomRoute(r, 'redirect')),
headers: headers.map((r: any) => buildCustomRoute(r, 'header')),
dynamicRoutes,
staticRoutes,
dataRoutes: [],
i18n: config.i18n || undefined,
rsc: {
header: RSC,
varyHeader: RSC_VARY_HEADER,
contentTypeHeader: RSC_CONTENT_TYPE_HEADER,
},
skipMiddlewareUrlNormalize: config.skipMiddlewareUrlNormalize,
}
})
return {
version: 3,
pages404: true,
caseSensitive: !!config.experimental.caseSensitiveRoutes,
basePath: config.basePath,
redirects: redirects.map((r: any) =>
buildCustomRoute(r, 'redirect')
),
headers: headers.map((r: any) => buildCustomRoute(r, 'header')),
dynamicRoutes,
staticRoutes,
dataRoutes: [],
i18n: config.i18n || undefined,
rsc: {
header: RSC,
varyHeader: RSC_VARY_HEADER,
contentTypeHeader: RSC_CONTENT_TYPE_HEADER,
},
skipMiddlewareUrlNormalize: config.skipMiddlewareUrlNormalize,
}
})
if (rewrites.beforeFiles.length === 0 && rewrites.fallback.length === 0) {
routesManifest.rewrites = rewrites.afterFiles.map((r: any) =>
......@@ -903,6 +923,7 @@ export default async function build(
]
: []),
path.join(SERVER_DIRECTORY, APP_PATHS_MANIFEST),
path.join(APP_PATH_ROUTES_MANIFEST),
APP_BUILD_MANIFEST,
path.join(
SERVER_DIRECTORY,
......@@ -1962,6 +1983,11 @@ export default async function build(
...Object.values(experimentalOverrides).map((override) =>
require.resolve(override)
),
...(config.experimental.turbotrace
? []
: Object.values(defaultOverrides).map((value) =>
require.resolve(value)
)),
]
// ensure we trace any dependencies needed for custom
......@@ -1979,9 +2005,7 @@ export default async function build(
const vanillaServerEntries = [
...sharedEntriesSet,
isStandalone
? require.resolve(
'next/dist/server/lib/render-server-standalone'
)
? require.resolve('next/dist/server/lib/start-server')
: null,
require.resolve('next/dist/server/next-server'),
].filter(Boolean) as string[]
......@@ -2158,49 +2182,7 @@ export default async function build(
...serverPropsPages,
...ssgPages,
]).map((page) => {
const pagePath = normalizePagePath(page)
const dataRoute = path.posix.join(
'/_next/data',
buildId,
`${pagePath}.json`
)
let dataRouteRegex: string
let namedDataRouteRegex: string | undefined
let routeKeys: { [named: string]: string } | undefined
if (isDynamicRoute(page)) {
const routeRegex = getNamedRouteRegex(
dataRoute.replace(/\.json$/, ''),
true
)
dataRouteRegex = normalizeRouteRegex(
routeRegex.re.source.replace(/\(\?:\\\/\)\?\$$/, `\\.json$`)
)
namedDataRouteRegex = routeRegex.namedRegex!.replace(
/\(\?:\/\)\?\$$/,
`\\.json$`
)
routeKeys = routeRegex.routeKeys
} else {
dataRouteRegex = normalizeRouteRegex(
new RegExp(
`^${path.posix.join(
'/_next/data',
escapeStringRegexp(buildId),
`${pagePath}.json`
)}$`
).source
)
}
return {
page,
routeKeys,
dataRouteRegex,
namedDataRouteRegex,
}
return buildDataRoute(page, buildId)
})
await fs.writeFile(
......
......@@ -1928,12 +1928,12 @@ export async function copyTracedFiles(
import path from 'path'
import { fileURLToPath } from 'url'
const __dirname = fileURLToPath(new URL('.', import.meta.url))
import { createServerHandler } from 'next/dist/server/lib/render-server-standalone.js'
import { startServer } from 'next/dist/server/lib/start-server.js'
`
: `
const http = require('http')
const path = require('path')
const { createServerHandler } = require('next/dist/server/lib/render-server-standalone')`
const { startServer } = require('next/dist/server/lib/start-server')`
}
const dir = path.join(__dirname)
......@@ -1950,11 +1950,7 @@ if (!process.env.NEXT_MANUAL_SIG_HANDLE) {
const currentPort = parseInt(process.env.PORT, 10) || 3000
const hostname = process.env.HOSTNAME || 'localhost'
const keepAliveTimeout = parseInt(process.env.KEEP_ALIVE_TIMEOUT, 10);
const isValidKeepAliveTimeout =
!Number.isNaN(keepAliveTimeout) &&
Number.isFinite(keepAliveTimeout) &&
keepAliveTimeout >= 0;
let keepAliveTimeout = parseInt(process.env.KEEP_ALIVE_TIMEOUT, 10);
const nextConfig = ${JSON.stringify({
...serverConfig,
distDir: `./${path.relative(dir, distDir)}`,
......@@ -1962,41 +1958,30 @@ const nextConfig = ${JSON.stringify({
process.env.__NEXT_PRIVATE_STANDALONE_CONFIG = JSON.stringify(nextConfig)
createServerHandler({
port: currentPort,
hostname,
dir,
conf: nextConfig,
keepAliveTimeout: isValidKeepAliveTimeout ? keepAliveTimeout : undefined,
}).then((nextHandler) => {
const server = http.createServer(async (req, res) => {
try {
await nextHandler(req, res)
} catch (err) {
console.error(err);
res.statusCode = 500
res.end('Internal Server Error')
}
})
if (isValidKeepAliveTimeout) {
server.keepAliveTimeout = keepAliveTimeout
}
server.listen(currentPort, async (err) => {
if (err) {
console.error("Failed to start server", err)
process.exit(1)
}
console.log(
'Listening on port',
currentPort,
'url: http://' + hostname + ':' + currentPort
)
});
if (
Number.isNaN(keepAliveTimeout) ||
!Number.isFinite(keepAliveTimeout) ||
keepAliveTimeout < 0
) {
keepAliveTimeout = undefined
}
}).catch(err => {
startServer({
dir,
isDev: false,
config: nextConfig,
hostname: hostname === 'localhost' ? '0.0.0.0' : hostname,
port: currentPort,
allowRetry: false,
keepAliveTimeout,
useWorkers: !!nextConfig.experimental?.appDir,
}).then(() => {
console.log(
'Listening on port',
currentPort,
'url: http://' + hostname + ':' + currentPort
)
}).catch((err) => {
console.error(err);
process.exit(1);
});`
......
......@@ -35,10 +35,27 @@ function generateClientManifest(
'NextJsBuildManifest-generateClientManifest'
)
const normalizeRewrite = (item: {
source: string
destination: string
has?: any
}) => {
return {
has: item.has,
source: item.source,
destination: item.destination,
}
}
return genClientManifestSpan?.traceFn(() => {
const clientManifest: ClientBuildManifest = {
// TODO: update manifest type to include rewrites
__rewrites: rewrites as any,
__rewrites: {
afterFiles: rewrites.afterFiles?.map((item) => normalizeRewrite(item)),
beforeFiles: rewrites.beforeFiles?.map((item) =>
normalizeRewrite(item)
),
fallback: rewrites.fallback?.map((item) => normalizeRewrite(item)),
} as any,
}
const appDependencies = new Set(assetMap.pages['/_app'])
const sortedPageKeys = getSortedRoutes(Object.keys(assetMap.pages))
......
......@@ -20,9 +20,15 @@ const originModules = [
const RUNTIME_NAMES = ['webpack-runtime', 'webpack-api-runtime']
const nextDeleteCacheRpc = async (filePaths: string[]) => {
if ((global as any)._nextDeleteCache) {
return (global as any)._nextDeleteCache(filePaths)
}
}
export function deleteAppClientCache() {
if ((global as any)._nextDeleteAppClientCache) {
;(global as any)._nextDeleteAppClientCache()
return (global as any)._nextDeleteAppClientCache()
}
// ensure we reset the cache for rsc components
// loaded via react-server-dom-webpack
......@@ -41,10 +47,6 @@ export function deleteAppClientCache() {
}
export function deleteCache(filePath: string) {
if ((global as any)._nextDeleteCache) {
;(global as any)._nextDeleteCache(filePath)
}
// try to clear it from the fs cache
clearManifestCache(filePath)
......@@ -86,7 +88,7 @@ export class NextJsRequireCacheHotReloader implements WebpackPluginInstance {
apply(compiler: Compiler) {
compiler.hooks.assetEmitted.tap(PLUGIN_NAME, (_file, { targetPath }) => {
deleteCache(targetPath)
nextDeleteCacheRpc([targetPath])
// Clear module context in other processes
if ((global as any)._nextClearModuleContext) {
......@@ -96,35 +98,33 @@ export class NextJsRequireCacheHotReloader implements WebpackPluginInstance {
clearModuleContext(targetPath)
})
compiler.hooks.afterEmit.tap(PLUGIN_NAME, (compilation) => {
RUNTIME_NAMES.forEach((name) => {
compiler.hooks.afterEmit.tapPromise(PLUGIN_NAME, async (compilation) => {
const cacheEntriesToDelete = []
for (const name of RUNTIME_NAMES) {
const runtimeChunkPath = path.join(
compilation.outputOptions.path!,
`${name}.js`
)
deleteCache(runtimeChunkPath)
})
let hasAppPath = false
cacheEntriesToDelete.push(runtimeChunkPath)
}
// we need to make sure to clear all server entries from cache
// since they can have a stale webpack-runtime cache
// which needs to always be in-sync
const entries = [...compilation.entries.keys()].filter((entry) => {
const isAppPath = entry.toString().startsWith('app/')
hasAppPath = hasAppPath || isAppPath
return entry.toString().startsWith('pages/') || isAppPath
})
if (hasAppPath) {
}
entries.forEach((page) => {
for (const page of entries) {
const outputPath = path.join(
compilation.outputOptions.path!,
page + '.js'
)
deleteCache(outputPath)
})
cacheEntriesToDelete.push(outputPath)
}
await nextDeleteCacheRpc(cacheEntriesToDelete)
})
}
}
......@@ -8,11 +8,7 @@ import isError from '../lib/is-error'
import { getProjectDir } from '../lib/get-project-dir'
import { CONFIG_FILES, PHASE_DEVELOPMENT_SERVER } from '../shared/lib/constants'
import path from 'path'
import {
defaultConfig,
NextConfig,
NextConfigComplete,
} from '../server/config-shared'
import { defaultConfig, NextConfigComplete } from '../server/config-shared'
import { traceGlobals } from '../trace/shared'
import { Telemetry } from '../telemetry/storage'
import loadConfig from '../server/config'
......@@ -26,6 +22,7 @@ import { getPossibleInstrumentationHookFilenames } from '../build/worker'
import { resetEnv } from '@next/env'
let dir: string
let config: NextConfigComplete
let isTurboSession = false
let sessionStopHandled = false
let sessionStarted = Date.now()
......@@ -38,13 +35,15 @@ const handleSessionStop = async () => {
const { eventCliSession } =
require('../telemetry/events/session-stopped') as typeof import('../telemetry/events/session-stopped')
const config = await loadConfig(
PHASE_DEVELOPMENT_SERVER,
dir,
undefined,
undefined,
true
)
config =
config ||
(await loadConfig(
PHASE_DEVELOPMENT_SERVER,
dir,
undefined,
undefined,
true
))
let telemetry =
(traceGlobals.get('telemetry') as InstanceType<
......@@ -211,12 +210,14 @@ const nextDev: CliCommand = async (argv) => {
// We do not set a default host value here to prevent breaking
// some set-ups that rely on listening on other interfaces
const host = args['--hostname']
config = await loadConfig(PHASE_DEVELOPMENT_SERVER, dir)
const devServerOptions: StartServerOptions = {
dir,
port,
allowRetry,
isDev: true,
nextConfig: config,
hostname: host,
// This is required especially for app dir.
useWorkers: true,
......@@ -237,14 +238,6 @@ const nextDev: CliCommand = async (argv) => {
resetEnv()
let bindings = await loadBindings()
const config = await loadConfig(
PHASE_DEVELOPMENT_SERVER,
dir,
undefined,
undefined,
true
)
// Just testing code here:
const project = await bindings.turbo.createProject({
......@@ -409,7 +402,6 @@ const nextDev: CliCommand = async (argv) => {
try {
let shouldFilter = false
let devServerTeardown: (() => Promise<void>) | undefined
let config: NextConfig | undefined
watchConfigFiles(devServerOptions.dir, (filename) => {
Log.warn(
......@@ -505,16 +497,6 @@ const nextDev: CliCommand = async (argv) => {
// fallback to noop, if not provided
resolveCleanup(async () => {})
}
if (!config) {
config = await loadConfig(
PHASE_DEVELOPMENT_SERVER,
dir,
undefined,
undefined,
true
)
}
}
await setupFork()
......
......@@ -84,6 +84,7 @@ const nextStart: CliCommand = async (argv) => {
await startServer({
dir,
nextConfig: config,
isDev: false,
hostname: host,
port,
......
......@@ -36,6 +36,7 @@ const supportedTurbopackNextConfigOptions = [
'experimental.isrFlushToDisk',
'experimental.workerThreads',
'experimenatl.pageEnv',
'experimental.caseSensitiveRoutes',
]
// The following will need to be supported by `next build --turbo`
......
import type { IncomingMessage } from 'http'
import type { BaseNextRequest } from '../base-http'
import type { CookieSerializeOptions } from 'next/dist/compiled/cookie'
import type { NextApiRequest, NextApiResponse } from '../../shared/lib/utils'
import type { NextApiResponse } from '../../shared/lib/utils'
import { HeadersAdapter } from '../web/spec-extension/adapters/headers'
import {
......@@ -186,7 +186,7 @@ export function sendError(
}
interface LazyProps {
req: NextApiRequest
req: IncomingMessage
}
/**
......
......@@ -475,16 +475,7 @@ async function revalidate(
headers: {},
}
)
const chunks = []
for await (const chunk of res) {
if (chunk) {
chunks.push(chunk)
}
}
const body = Buffer.concat(chunks).toString()
const result = JSON.parse(body)
const result = await res.json()
if (result.err) {
throw new Error(result.err.message)
......
This diff is collapsed.
let installed: boolean = false
export function loadWebpackHook({ init }: { init: boolean }) {
if (init) {
const { init: initWebpack } = require('next/dist/compiled/webpack/webpack')
if (installed) {
return
}
installed = true
initWebpack()
export function loadWebpackHook() {
const { init: initWebpack } = require('next/dist/compiled/webpack/webpack')
if (installed) {
return
}
installed = true
initWebpack()
// hook the Node.js require so that webpack requires are
// routed to the bundled and now initialized webpack version
......
......@@ -711,25 +711,22 @@ export default async function loadConfig(
rawConfig?: boolean,
silent?: boolean
): Promise<NextConfigComplete> {
if (!process.env.__NEXT_PRIVATE_RENDER_WORKER) {
try {
loadWebpackHook()
} catch (err) {
// this can fail in standalone mode as the files
// aren't traced/included
if (!process.env.__NEXT_PRIVATE_STANDALONE_CONFIG) {
throw err
}
}
}
if (process.env.__NEXT_PRIVATE_STANDALONE_CONFIG) {
return JSON.parse(process.env.__NEXT_PRIVATE_STANDALONE_CONFIG)
}
const curLog = silent
? {
warn: () => {},
info: () => {},
error: () => {},
}
: Log
loadEnvConfig(dir, phase === PHASE_DEVELOPMENT_SERVER, curLog)
loadWebpackHook({
// For render workers, there's no need to init webpack eagerly
init: !process.env.__NEXT_PRIVATE_RENDER_WORKER,
})
// For the render worker, we directly return the serialized config from the
// parent worker (router worker) to avoid loading it again.
// This is because loading the config might be expensive especiall when people
......@@ -740,6 +737,16 @@ export default async function loadConfig(
return JSON.parse(process.env.__NEXT_PRIVATE_RENDER_WORKER_CONFIG)
}
const curLog = silent
? {
warn: () => {},
info: () => {},
error: () => {},
}
: Log
loadEnvConfig(dir, phase === PHASE_DEVELOPMENT_SERVER, curLog)
let configFileName = 'next.config.js'
if (customConfig) {
......
......@@ -279,7 +279,7 @@ export default class HotReloader {
parsedPageBundleUrl: UrlObject
): Promise<{ finished?: true }> => {
const { pathname } = parsedPageBundleUrl
const params = matchNextPageBundleRequest<{ path: string[] }>(pathname)
const params = matchNextPageBundleRequest(pathname)
if (!params) {
return {}
}
......@@ -288,7 +288,7 @@ export default class HotReloader {
try {
decodedPagePath = `/${params.path
.map((param) => decodeURIComponent(param))
.map((param: string) => decodeURIComponent(param))
.join('/')}`
} catch (_) {
throw new DecodeError('failed to decode param')
......@@ -1411,10 +1411,12 @@ export default class HotReloader {
clientOnly,
appPaths,
match,
isApp,
}: {
page: string
clientOnly: boolean
appPaths?: string[] | null
isApp?: boolean
match?: RouteMatch
}): Promise<void> {
// Make sure we don't re-build or dispose prebuilt pages
......@@ -1432,6 +1434,7 @@ export default class HotReloader {
clientOnly,
appPaths,
match,
isApp,
}) as any
}
}
......@@ -689,11 +689,13 @@ export function onDemandEntryHandler({
clientOnly,
appPaths = null,
match,
isApp,
}: {
page: string
clientOnly: boolean
appPaths?: ReadonlyArray<string> | null
match?: RouteMatch
isApp?: boolean
}): Promise<void> {
const stalledTime = 60
const stalledEnsureTimeout = setTimeout(() => {
......@@ -722,6 +724,12 @@ export function onDemandEntryHandler({
const isInsideAppDir =
!!appDir && pagePathData.absolutePagePath.startsWith(appDir)
if (typeof isApp === 'boolean' && !(isApp === isInsideAppDir)) {
throw new Error(
'Ensure bailed, found path does not match ensure type (pages/app)'
)
}
const pageBundleType = getPageBundleType(pagePathData.bundlePath)
const addEntry = (
compilerType: CompilerNameValues
......@@ -894,11 +902,13 @@ export function onDemandEntryHandler({
clientOnly,
appPaths = null,
match,
isApp,
}: {
page: string
clientOnly: boolean
appPaths?: ReadonlyArray<string> | null
match?: RouteMatch
isApp?: boolean
}) {
if (curEnsurePage.has(page)) {
return curEnsurePage.get(page)
......@@ -908,6 +918,7 @@ export function onDemandEntryHandler({
clientOnly,
appPaths,
match,
isApp,
}).finally(() => {
curEnsurePage.delete(page)
})
......
import type { IncomingMessage, ServerResponse } from 'http'
import type { ChildProcess } from 'child_process'
import httpProxy from 'next/dist/compiled/http-proxy'
import { Worker } from 'next/dist/compiled/jest-worker'
import { normalizeRepeatedSlashes } from '../../shared/lib/utils'
export const createServerHandler = async ({
port,
hostname,
dir,
dev = false,
minimalMode,
keepAliveTimeout,
}: {
port: number
hostname: string
dir: string
dev?: boolean
minimalMode: boolean
keepAliveTimeout?: number
}) => {
const routerWorker = new Worker(require.resolve('./render-server'), {
numWorkers: 1,
maxRetries: 10,
forkOptions: {
env: {
FORCE_COLOR: '1',
...process.env,
},
},
exposedMethods: ['initialize'],
}) as any as InstanceType<typeof Worker> & {
initialize: typeof import('./render-server').initialize
}
let didInitialize = false
for (const _worker of ((routerWorker as any)._workerPool?._workers || []) as {
_child: ChildProcess
}[]) {
// eslint-disable-next-line no-loop-func
_worker._child.on('exit', (code, signal) => {
// catch failed initializing without retry
if ((code || signal) && !didInitialize) {
routerWorker?.end()
process.exit(1)
}
})
}
const workerStdout = routerWorker.getStdout()
const workerStderr = routerWorker.getStderr()
workerStdout.on('data', (data) => {
process.stdout.write(data)
})
workerStderr.on('data', (data) => {
process.stderr.write(data)
})
const { port: routerPort } = await routerWorker.initialize({
dir,
port,
dev,
hostname,
minimalMode,
workerType: 'router',
isNodeDebugging: false,
keepAliveTimeout,
})
didInitialize = true
const getProxyServer = (pathname: string) => {
const targetUrl = `http://${
hostname === 'localhost' ? '127.0.0.1' : hostname
}:${routerPort}${pathname}`
const proxyServer = httpProxy.createProxy({
target: targetUrl,
changeOrigin: false,
ignorePath: true,
xfwd: true,
ws: true,
followRedirects: false,
})
return proxyServer
}
// proxy to router worker
return async (req: IncomingMessage, res: ServerResponse) => {
const urlParts = (req.url || '').split('?')
const urlNoQuery = urlParts[0]
// this normalizes repeated slashes in the path e.g. hello//world ->
// hello/world or backslashes to forward slashes, this does not
// handle trailing slash as that is handled the same as a next.config.js
// redirect
if (urlNoQuery?.match(/(\\|\/\/)/)) {
const cleanUrl = normalizeRepeatedSlashes(req.url!)
res.statusCode = 308
res.setHeader('Location', cleanUrl)
res.end(cleanUrl)
return
}
const proxyServer = getProxyServer(req.url || '/')
// http-proxy does not properly detect a client disconnect in newer
// versions of Node.js. This is caused because it only listens for the
// `aborted` event on the our request object, but it also fully reads and
// closes the request object. Node **will not** fire `aborted` when the
// request is already closed. Listening for `close` on our response object
// will detect the disconnect, and we can abort the proxy's connection.
proxyServer.on('proxyReq', (proxyReq) => {
res.on('close', () => proxyReq.destroy())
})
proxyServer.on('proxyRes', (proxyRes) => {
res.on('close', () => proxyRes.destroy())
})
proxyServer.web(req, res)
proxyServer.on('error', (err) => {
res.statusCode = 500
res.end('Internal Server Error')
console.error(err)
})
}
}
import type { RequestHandler } from '../next'
import './cpu-profile'
import v8 from 'v8'
import http from 'http'
import { isIPv6 } from 'net'
// This is required before other imports to ensure the require hook is setup.
import '../require-hook'
// this must come first as it includes require hooks
import { initializeServerWorker } from './setup-server-worker'
import next from '../next'
import { warn } from '../../build/output/log'
import { getFreePort } from '../lib/worker-utils'
export const WORKER_SELF_EXIT_CODE = 77
const MAXIMUM_HEAP_SIZE_ALLOWED =
(v8.getHeapStatistics().heap_size_limit / 1024 / 1024) * 0.9
let result:
| undefined
| {
......@@ -24,6 +13,8 @@ let result:
hostname: string
}
let app: ReturnType<typeof next> | undefined
let sandboxContext: undefined | typeof import('../web/sandbox/context')
let requireCacheHotReloader:
| undefined
......@@ -35,15 +26,46 @@ if (process.env.NODE_ENV !== 'production') {
}
export function clearModuleContext(target: string) {
sandboxContext?.clearModuleContext(target)
return sandboxContext?.clearModuleContext(target)
}
export function deleteAppClientCache() {
requireCacheHotReloader?.deleteAppClientCache()
return requireCacheHotReloader?.deleteAppClientCache()
}
export function deleteCache(filePaths: string[]) {
for (const filePath of filePaths) {
requireCacheHotReloader?.deleteCache(filePath)
}
}
export function deleteCache(filePath: string) {
requireCacheHotReloader?.deleteCache(filePath)
export async function propagateServerField(field: string, value: any) {
if (!app) {
throw new Error('Invariant cant propagate server field, no app initialized')
}
let appField = (app as any).server
if (field.includes('.')) {
const parts = field.split('.')
for (let i = 0; i < parts.length - 1; i++) {
if (appField) {
appField = appField[parts[i]]
}
}
field = parts[parts.length - 1]
}
if (appField) {
if (typeof appField[field] === 'function') {
appField[field].apply(
(app as any).server,
Array.isArray(value) ? value : []
)
} else {
appField[field] = value
}
}
}
export async function initialize(opts: {
......@@ -55,6 +77,7 @@ export async function initialize(opts: {
workerType: 'router' | 'render'
isNodeDebugging: boolean
keepAliveTimeout?: number
serverFields?: any
}): Promise<NonNullable<typeof result>> {
// if we already setup the server return as we only need to do
// this on first worker boot
......@@ -62,97 +85,40 @@ export async function initialize(opts: {
return result
}
const isRouterWorker = opts.workerType === 'router'
const isRenderWorker = opts.workerType === 'render'
if (isRouterWorker) {
process.title = 'next-router-worker'
} else if (isRenderWorker) {
const type = process.env.__NEXT_PRIVATE_RENDER_WORKER!
process.title = 'next-render-worker-' + type
}
const type = process.env.__NEXT_PRIVATE_RENDER_WORKER!
process.title = 'next-render-worker-' + type
let requestHandler: RequestHandler
const server = http.createServer((req, res) => {
return requestHandler(req, res)
.catch((err) => {
res.statusCode = 500
res.end('Internal Server Error')
console.error(err)
})
.finally(() => {
if (
process.memoryUsage().heapUsed / 1024 / 1024 >
MAXIMUM_HEAP_SIZE_ALLOWED
) {
warn(
'The server is running out of memory, restarting to free up memory.'
)
server.close()
process.exit(WORKER_SELF_EXIT_CODE)
}
})
let upgradeHandler: any
const { port, server, hostname } = await initializeServerWorker(
(...args) => {
return requestHandler(...args)
},
(...args) => {
return upgradeHandler(...args)
},
opts
)
app = next({
...opts,
_routerWorker: opts.workerType === 'router',
_renderWorker: opts.workerType === 'render',
hostname: hostname === '0.0.0.0' ? 'localhost' : hostname,
customServer: false,
httpServer: server,
port: opts.port,
isNodeDebugging: opts.isNodeDebugging,
})
if (opts.keepAliveTimeout) {
server.keepAliveTimeout = opts.keepAliveTimeout
}
return new Promise(async (resolve, reject) => {
server.on('error', (err: NodeJS.ErrnoException) => {
console.error(`Invariant: failed to start render worker`, err)
process.exit(1)
})
requestHandler = app.getRequestHandler()
upgradeHandler = app.getUpgradeHandler()
await app.prepare(opts.serverFields)
let upgradeHandler: any
if (!opts.dev) {
server.on('upgrade', (req, socket, upgrade) => {
upgradeHandler(req, socket, upgrade)
})
}
server.on('listening', async () => {
try {
const addr = server.address()
const port = addr && typeof addr === 'object' ? addr.port : 0
if (!port) {
console.error(`Invariant failed to detect render worker port`, addr)
process.exit(1)
}
let hostname =
!opts.hostname || opts.hostname === '0.0.0.0'
? 'localhost'
: opts.hostname
if (isIPv6(hostname)) {
hostname = hostname === '::' ? '[::1]' : `[${hostname}]`
}
result = {
port,
hostname,
}
const app = next({
...opts,
_routerWorker: isRouterWorker,
_renderWorker: isRenderWorker,
hostname,
customServer: false,
httpServer: server,
port: opts.port,
isNodeDebugging: opts.isNodeDebugging,
})
requestHandler = app.getRequestHandler()
upgradeHandler = app.getUpgradeHandler()
await app.prepare()
resolve(result)
} catch (err) {
return reject(err)
}
})
server.listen(await getFreePort(), '0.0.0.0')
})
result = {
port,
hostname: hostname === '0.0.0.0' ? '127.0.0.1' : hostname,
}
return result
}
This diff is collapsed.
import path from '../../../shared/lib/isomorphic/path'
import { normalizePagePath } from '../../../shared/lib/page-path/normalize-page-path'
import { isDynamicRoute } from '../../../shared/lib/router/utils/is-dynamic'
import { getNamedRouteRegex } from '../../../shared/lib/router/utils/route-regex'
import { normalizeRouteRegex } from '../../../lib/load-custom-routes'
import { escapeStringRegexp } from '../../../shared/lib/escape-regexp'
export function buildDataRoute(page: string, buildId: string) {
const pagePath = normalizePagePath(page)
const dataRoute = path.posix.join('/_next/data', buildId, `${pagePath}.json`)
let dataRouteRegex: string
let namedDataRouteRegex: string | undefined
let routeKeys: { [named: string]: string } | undefined
if (isDynamicRoute(page)) {
const routeRegex = getNamedRouteRegex(
dataRoute.replace(/\.json$/, ''),
true
)
dataRouteRegex = normalizeRouteRegex(
routeRegex.re.source.replace(/\(\?:\\\/\)\?\$$/, `\\.json$`)
)
namedDataRouteRegex = routeRegex.namedRegex!.replace(
/\(\?:\/\)\?\$$/,
`\\.json$`
)
routeKeys = routeRegex.routeKeys
} else {
dataRouteRegex = normalizeRouteRegex(
new RegExp(
`^${path.posix.join(
'/_next/data',
escapeStringRegexp(buildId),
`${pagePath}.json`
)}$`
).source
)
}
return {
page,
routeKeys,
dataRouteRegex,
namedDataRouteRegex,
}
}
This diff is collapsed.
import type { IncomingMessage, ServerResponse } from 'http'
import type { NextUrlWithParsedQuery } from '../../request-meta'
import url from 'url'
import { stringifyQuery } from '../../server-route-utils'
export async function proxyRequest(
req: IncomingMessage,
res: ServerResponse,
parsedUrl: NextUrlWithParsedQuery,
upgradeHead?: any,
reqBody?: any,
proxyTimeout?: number | null
) {
const { query } = parsedUrl
delete (parsedUrl as any).query
parsedUrl.search = stringifyQuery(req as any, query)
const target = url.format(parsedUrl)
const HttpProxy =
require('next/dist/compiled/http-proxy') as typeof import('next/dist/compiled/http-proxy')
const proxy = new HttpProxy({
target,
changeOrigin: true,
ignorePath: true,
xfwd: true,
ws: true,
// we limit proxy requests to 30s by default, in development
// we don't time out WebSocket requests to allow proxying
proxyTimeout: proxyTimeout === null ? undefined : proxyTimeout || 30_000,
})
await new Promise((proxyResolve, proxyReject) => {
let finished = false
proxy.on('proxyRes', (proxyRes, innerReq, innerRes) => {
const cleanup = (err: any) => {
// cleanup event listeners to allow clean garbage collection
proxyRes.removeListener('error', cleanup)
proxyRes.removeListener('close', cleanup)
innerRes.removeListener('error', cleanup)
innerRes.removeListener('close', cleanup)
// destroy all source streams to propagate the caught event backward
innerReq.destroy(err)
proxyRes.destroy(err)
}
proxyRes.once('error', cleanup)
proxyRes.once('close', cleanup)
innerRes.once('error', cleanup)
innerRes.once('close', cleanup)
})
proxy.on('error', (err) => {
console.error(`Failed to proxy ${target}`, err)
if (!finished) {
finished = true
proxyReject(err)
if (!res.closed) {
res.statusCode = 500
res.end('Internal Server Error')
}
}
})
// if upgrade head is present treat as WebSocket request
if (upgradeHead) {
proxy.on('proxyReqWs', (proxyReq) => {
proxyReq.on('close', () => {
if (!finished) {
finished = true
proxyResolve(true)
}
})
})
proxy.ws(req as any as IncomingMessage, res, upgradeHead)
proxyResolve(true)
} else {
proxy.on('proxyReq', (proxyReq) => {
proxyReq.on('close', () => {
if (!finished) {
finished = true
proxyResolve(true)
}
})
})
proxy.web(req, res, {
buffer: reqBody,
})
}
})
}
This diff is collapsed.
This diff is collapsed.
......@@ -88,13 +88,14 @@ export const createWorker = async (
nextConfig: NextConfigComplete
) => {
const { initialEnv } = require('@next/env') as typeof import('@next/env')
const { Worker } = require('next/dist/compiled/jest-worker')
const useServerActions = !!nextConfig.experimental.serverActions
const { Worker } =
require('next/dist/compiled/jest-worker') as typeof import('next/dist/compiled/jest-worker')
const worker = new Worker(require.resolve('../render-server'), {
numWorkers: 1,
// TODO: do we want to allow more than 10 OOM restarts?
maxRetries: 10,
// TODO: do we want to allow more than 8 OOM restarts?
maxRetries: 8,
forkOptions: {
env: {
FORCE_COLOR: '1',
......@@ -129,11 +130,14 @@ export const createWorker = async (
'deleteCache',
'deleteAppClientCache',
'clearModuleContext',
'propagateServerField',
],
}) as any as InstanceType<typeof Worker> & {
initialize: typeof import('../render-server').initialize
deleteCache: typeof import('../render-server').deleteCache
deleteAppClientCache: typeof import('../render-server').deleteAppClientCache
clearModuleContext: typeof import('../render-server').clearModuleContext
propagateServerField: typeof import('../render-server').propagateServerField
}
worker.getStderr().pipe(process.stderr)
......
export const forbiddenHeaders = [
'accept-encoding',
'keepalive',
'keep-alive',
'content-encoding',
'transfer-encoding',
// https://github.com/nodejs/undici/issues/1470
......@@ -8,7 +9,7 @@ export const forbiddenHeaders = [
]
export const filterReqHeaders = (
headers: Record<string, undefined | string | string[]>
headers: Record<string, undefined | string | number | string[]>
) => {
for (const [key, value] of Object.entries(headers)) {
if (
......@@ -18,5 +19,5 @@ export const filterReqHeaders = (
delete headers[key]
}
}
return headers
return headers as Record<string, undefined | string | string[]>
}
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
......@@ -10,10 +10,11 @@ send.mime.define({
export function serveStatic(
req: IncomingMessage,
res: ServerResponse,
path: string
path: string,
opts?: Parameters<typeof send>[2]
): Promise<void> {
return new Promise((resolve, reject) => {
send(req, path)
send(req, path, opts)
.on('directory', () => {
// We don't allow directories to be read.
const err: any = new Error('No directory access')
......
This diff is collapsed.
......@@ -6,6 +6,9 @@ createNextDescribe(
files: __dirname,
skipDeployment: true,
startCommand: 'node server.js',
dependencies: {
'get-port': '5.1.1',
},
},
({ next }) => {
it.each(['/', '/render'])('should render %s', async (page) => {
......
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment