248 lines
7.9 KiB
TypeScript
248 lines
7.9 KiB
TypeScript
import { logger, field } from "@coder/logger"
|
|
import * as cp from "child_process"
|
|
import * as fs from "fs-extra"
|
|
import * as path from "path"
|
|
import { Emitter } from "../common/emitter"
|
|
|
|
interface HandshakeMessage {
|
|
type: "handshake"
|
|
}
|
|
|
|
interface RelaunchMessage {
|
|
type: "relaunch"
|
|
version: string
|
|
}
|
|
|
|
export type Message = RelaunchMessage | HandshakeMessage
|
|
|
|
export class ProcessError extends Error {
|
|
public constructor(message: string, public readonly code: number | undefined) {
|
|
super(message)
|
|
this.name = this.constructor.name
|
|
Error.captureStackTrace(this, this.constructor)
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Allows the wrapper and inner processes to communicate.
|
|
*/
|
|
export class IpcMain {
|
|
private readonly _onMessage = new Emitter<Message>()
|
|
public readonly onMessage = this._onMessage.event
|
|
private readonly _onDispose = new Emitter<NodeJS.Signals | undefined>()
|
|
public readonly onDispose = this._onDispose.event
|
|
public readonly exit: (code?: number) => never
|
|
|
|
public constructor(public readonly parentPid?: number) {
|
|
process.on("SIGINT", () => this._onDispose.emit("SIGINT"))
|
|
process.on("SIGTERM", () => this._onDispose.emit("SIGTERM"))
|
|
process.on("exit", () => this._onDispose.emit(undefined))
|
|
|
|
// Ensure we control when the process exits.
|
|
this.exit = process.exit
|
|
process.exit = function(code?: number) {
|
|
logger.warn(`process.exit() was prevented: ${code || "unknown code"}.`)
|
|
} as (code?: number) => never
|
|
|
|
this.onDispose((signal) => {
|
|
// Remove listeners to avoid possibly triggering disposal again.
|
|
process.removeAllListeners()
|
|
|
|
// Let any other handlers run first then exit.
|
|
logger.debug(`${parentPid ? "inner process" : "wrapper"} ${process.pid} disposing`, field("code", signal))
|
|
setTimeout(() => this.exit(0), 0)
|
|
})
|
|
|
|
// Kill the inner process if the parent dies. This is for the case where the
|
|
// parent process is forcefully terminated and cannot clean up.
|
|
if (parentPid) {
|
|
setInterval(() => {
|
|
try {
|
|
// process.kill throws an exception if the process doesn't exist.
|
|
process.kill(parentPid, 0)
|
|
} catch (_) {
|
|
// Consider this an error since it should have been able to clean up
|
|
// the child process unless it was forcefully killed.
|
|
logger.error(`parent process ${parentPid} died`)
|
|
this._onDispose.emit(undefined)
|
|
}
|
|
}, 5000)
|
|
}
|
|
}
|
|
|
|
public handshake(child?: cp.ChildProcess): Promise<void> {
|
|
return new Promise((resolve, reject) => {
|
|
const target = child || process
|
|
const onMessage = (message: Message): void => {
|
|
logger.debug(
|
|
`${child ? "wrapper" : "inner process"} ${process.pid} received message from ${
|
|
child ? child.pid : this.parentPid
|
|
}`,
|
|
field("message", message),
|
|
)
|
|
if (message.type === "handshake") {
|
|
target.removeListener("message", onMessage)
|
|
target.on("message", (msg) => this._onMessage.emit(msg))
|
|
// The wrapper responds once the inner process starts the handshake.
|
|
if (child) {
|
|
if (!target.send) {
|
|
throw new Error("child not spawned with IPC")
|
|
}
|
|
target.send({ type: "handshake" })
|
|
}
|
|
resolve()
|
|
}
|
|
}
|
|
target.on("message", onMessage)
|
|
if (child) {
|
|
child.once("error", reject)
|
|
child.once("exit", (code) => {
|
|
reject(new ProcessError(`Unexpected exit with code ${code}`, code !== null ? code : undefined))
|
|
})
|
|
} else {
|
|
// The inner process initiates the handshake.
|
|
this.send({ type: "handshake" })
|
|
}
|
|
})
|
|
}
|
|
|
|
public relaunch(version: string): void {
|
|
this.send({ type: "relaunch", version })
|
|
}
|
|
|
|
private send(message: Message): void {
|
|
if (!process.send) {
|
|
throw new Error("not spawned with IPC")
|
|
}
|
|
process.send(message)
|
|
}
|
|
}
|
|
|
|
let _ipcMain: IpcMain
|
|
export const ipcMain = (): IpcMain => {
|
|
if (!_ipcMain) {
|
|
_ipcMain = new IpcMain(
|
|
typeof process.env.CODE_SERVER_PARENT_PID !== "undefined"
|
|
? parseInt(process.env.CODE_SERVER_PARENT_PID)
|
|
: undefined,
|
|
)
|
|
}
|
|
return _ipcMain
|
|
}
|
|
|
|
export interface WrapperOptions {
|
|
maxMemory?: number
|
|
nodeOptions?: string
|
|
}
|
|
|
|
/**
|
|
* Provides a way to wrap a process for the purpose of updating the running
|
|
* instance.
|
|
*/
|
|
export class WrapperProcess {
|
|
private process?: cp.ChildProcess
|
|
private started?: Promise<void>
|
|
|
|
public constructor(private currentVersion: string, private readonly options?: WrapperOptions) {
|
|
ipcMain().onDispose(() => {
|
|
if (this.process) {
|
|
this.process.removeAllListeners()
|
|
this.process.kill()
|
|
}
|
|
})
|
|
|
|
ipcMain().onMessage(async (message) => {
|
|
switch (message.type) {
|
|
case "relaunch":
|
|
logger.info(`Relaunching: ${this.currentVersion} -> ${message.version}`)
|
|
this.currentVersion = message.version
|
|
this.started = undefined
|
|
if (this.process) {
|
|
this.process.removeAllListeners()
|
|
this.process.kill()
|
|
}
|
|
try {
|
|
await this.start()
|
|
} catch (error) {
|
|
logger.error(error.message)
|
|
ipcMain().exit(typeof error.code === "number" ? error.code : 1)
|
|
}
|
|
break
|
|
default:
|
|
logger.error(`Unrecognized message ${message}`)
|
|
break
|
|
}
|
|
})
|
|
}
|
|
|
|
public start(): Promise<void> {
|
|
if (!this.started) {
|
|
this.started = this.spawn().then((child) => {
|
|
logger.debug(`spawned inner process ${child.pid}`)
|
|
ipcMain()
|
|
.handshake(child)
|
|
.then(() => {
|
|
child.once("exit", (code) => {
|
|
logger.debug(`inner process ${child.pid} exited unexpectedly`)
|
|
ipcMain().exit(code || 0)
|
|
})
|
|
})
|
|
this.process = child
|
|
})
|
|
}
|
|
return this.started
|
|
}
|
|
|
|
private async spawn(): Promise<cp.ChildProcess> {
|
|
// Flags to pass along to the Node binary.
|
|
let nodeOptions = `${process.env.NODE_OPTIONS || ""} ${(this.options && this.options.nodeOptions) || ""}`
|
|
if (!/max_old_space_size=(\d+)/g.exec(nodeOptions)) {
|
|
nodeOptions += ` --max_old_space_size=${(this.options && this.options.maxMemory) || 2048}`
|
|
}
|
|
|
|
// This is to handle the upgrade from binary release to loose release. This
|
|
// will only work for users that restart code-server entirely between
|
|
// upgrading to this version and the loose file version since this is the
|
|
// wrapper code that does not get updated. The hope is that it'll be likely
|
|
// for that to happen to most users in that timeframe to minimize disruption
|
|
// when loose files are release. This can be removed with that release.
|
|
const bundledNodePath = path.join(process.argv[0], "node")
|
|
const binary = (await fs.pathExists(bundledNodePath)) ? bundledNodePath : process.argv[0]
|
|
|
|
// Use spawn (instead of fork) to use the new binary in case it was updated.
|
|
return cp.spawn(binary, process.argv.slice(1), {
|
|
env: {
|
|
...process.env,
|
|
CODE_SERVER_PARENT_PID: process.pid.toString(),
|
|
NODE_OPTIONS: nodeOptions,
|
|
NBIN_BYPASS: undefined,
|
|
},
|
|
stdio: ["inherit", "inherit", "inherit", "ipc"],
|
|
})
|
|
}
|
|
}
|
|
|
|
// It's possible that the pipe has closed (for example if you run code-server
|
|
// --version | head -1). Assume that means we're done.
|
|
if (!process.stdout.isTTY) {
|
|
process.stdout.on("error", () => ipcMain().exit())
|
|
}
|
|
|
|
export const wrap = (fn: () => Promise<void>): void => {
|
|
if (ipcMain().parentPid) {
|
|
ipcMain()
|
|
.handshake()
|
|
.then(() => fn())
|
|
.catch((error: ProcessError): void => {
|
|
logger.error(error.message)
|
|
ipcMain().exit(typeof error.code === "number" ? error.code : 1)
|
|
})
|
|
} else {
|
|
const wrapper = new WrapperProcess(require("../../package.json").version)
|
|
wrapper.start().catch((error) => {
|
|
logger.error(error.message)
|
|
ipcMain().exit(typeof error.code === "number" ? error.code : 1)
|
|
})
|
|
}
|
|
}
|