code-server/src/node/wrapper.ts at v4.102.0 · coder/code-server · GitHub

History

397 lines (344 loc) · 11 KB

Raw

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

import { field, Logger, logger } from "@coder/logger"

import * as cp from "child_process"

import * as path from "path"

import * as rfs from "rotating-file-stream"

import { Emitter } from "../common/emitter"

import { DefaultedArgs, redactArgs } from "./cli"

import { paths } from "./util"

const timeoutInterval = 10000 // 10s, matches VS Code's timeouts.

/**

* Listen to a single message from a process. Reject if the process errors,

* exits, or times out.

* `fn` is a function that determines whether the message is the one we're

* waiting for.

export function onMessage<M, T extends M>(

proc: cp.ChildProcess | NodeJS.Process,

fn: (message: M) => message is T,

customLogger?: Logger,

): Promise<T> {

return new Promise((resolve, reject) => {

const cleanup = () => {

proc.off("error", onError)

proc.off("exit", onExit)

proc.off("message", onMessage)

clearTimeout(timeout)

}

const timeout = setTimeout(() => {

cleanup()

reject(new Error("timed out"))

}, timeoutInterval)

const onError = (error: Error) => {

cleanup()

reject(error)

}

const onExit = (code: number) => {

cleanup()

reject(new Error(`exited unexpectedly with code ${code}`))

}

const onMessage = (message: M) => {

if (fn(message)) {

cleanup()

resolve(message)

} else {

;(customLogger || logger).debug("got unhandled message", field("message", message))

}

proc.on("message", onMessage)

// NodeJS.Process doesn't have `error` but binding anyway shouldn't break

// anything. It does have `exit` but the types aren't working.

;(proc as cp.ChildProcess).on("error", onError)

;(proc as cp.ChildProcess).on("exit", onExit)

})

}

interface ParentHandshakeMessage {

type: "handshake"

args: DefaultedArgs

}

interface ChildHandshakeMessage {

type: "handshake"

}

interface RelaunchMessage {

type: "relaunch"

version: string

}

type ChildMessage = RelaunchMessage | ChildHandshakeMessage

type ParentMessage = ParentHandshakeMessage

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)

}

/**

* Wrapper around a process that tries to gracefully exit when a process exits

* and provides a way to prevent `process.exit`.

abstract class Process {

/**

* Emit this to trigger a graceful exit.

protected readonly _onDispose = new Emitter<NodeJS.Signals | undefined>()

/**

* Emitted when the process is about to be disposed.

public readonly onDispose = this._onDispose.event

/**

* Uniquely named logger for the process.

public abstract logger: Logger

public constructor() {

process.on("SIGINT", () => this._onDispose.emit("SIGINT"))

process.on("SIGTERM", () => this._onDispose.emit("SIGTERM"))

process.on("exit", () => this._onDispose.emit(undefined))

this.onDispose((signal, wait) => {

// Remove listeners to avoid possibly triggering disposal again.

process.removeAllListeners()

// Try waiting for other handlers to run first then exit.

this.logger.debug("disposing", field("code", signal))

wait.then(() => this.exit(0))

setTimeout(() => this.exit(0), 5000)

})

}

/**

* Ensure control over when the process exits.

public preventExit(): void {

;(process.exit as any) = (code?: number) => {

this.logger.warn(`process.exit() was prevented: ${code || "unknown code"}.`)

}

private readonly processExit: (code?: number) => never = process.exit

/**

* Will always exit even if normal exit is being prevented.

public exit(error?: number | ProcessError): never {

if (error && typeof error !== "number") {

this.processExit(typeof error.code === "number" ? error.code : 1)

} else {

this.processExit(error)

}

/**

* Child process that will clean up after itself if the parent goes away and can

* perform a handshake with the parent and ask it to relaunch.

export class ChildProcess extends Process {

public logger = logger.named(`child:${process.pid}`)

public constructor(private readonly parentPid: number) {

super()

// Kill the inner process if the parent dies. This is for the case where the

// parent process is forcefully terminated and cannot clean up.

setInterval(() => {

try {

// process.kill throws an exception if the process doesn't exist.

process.kill(this.parentPid, 0)

} catch (_) {

// Consider this an error since it should have been able to clean up

// the child process unless it was forcefully killed.

this.logger.error(`parent process ${parentPid} died`)

this._onDispose.emit(undefined)

}

}, 5000)

}

/**

* Initiate the handshake and wait for a response from the parent.

public async handshake(): Promise<DefaultedArgs> {

this.logger.debug("initiating handshake")

this.send({ type: "handshake" })

const message = await onMessage<ParentMessage, ParentHandshakeMessage>(

process,

(message): message is ParentHandshakeMessage => {

return message.type === "handshake"

this.logger,

)

this.logger.debug(

"got message",

field("message", {

type: message.type,

args: redactArgs(message.args),

}),

)

return message.args

}

/**

* Notify the parent process that it should relaunch the child.

public relaunch(version: string): void {

this.send({ type: "relaunch", version })

}

/**

* Send a message to the parent.

private send(message: ChildMessage): void {

if (!process.send) {

throw new Error("not spawned with IPC")

}

process.send(message)

}

/**

* Parent process wrapper that spawns the child process and performs a handshake

* with it. Will relaunch the child if it receives a SIGUSR1 or SIGUSR2 or is

* asked to by the child. If the child otherwise exits the parent will also

* exit.

export class ParentProcess extends Process {

public logger = logger.named(`parent:${process.pid}`)

private child?: cp.ChildProcess

private started?: Promise<void>

private readonly logStdoutStream: rfs.RotatingFileStream

private readonly logStderrStream: rfs.RotatingFileStream

protected readonly _onChildMessage = new Emitter<ChildMessage>()

protected readonly onChildMessage = this._onChildMessage.event

private args?: DefaultedArgs

public constructor(private currentVersion: string) {

super()

process.on("SIGUSR1", async () => {

this.logger.info("Received SIGUSR1; hotswapping")

this.relaunch()

})

process.on("SIGUSR2", async () => {

this.logger.info("Received SIGUSR2; hotswapping")

this.relaunch()

})

const opts = {

size: "10M",

maxFiles: 10,

path: path.join(paths.data, "coder-logs"),

}

this.logStdoutStream = rfs.createStream("code-server-stdout.log", opts)

this.logStderrStream = rfs.createStream("code-server-stderr.log", opts)

this.onDispose(() => this.disposeChild())

this.onChildMessage((message) => {

switch (message.type) {

case "relaunch":

this.logger.info(`Relaunching: ${this.currentVersion} -> ${message.version}`)

this.currentVersion = message.version

this.relaunch()

break

default:

this.logger.error(`Unrecognized message ${message}`)

break

}

})

}

private async disposeChild(): Promise<void> {

this.started = undefined

if (this.child) {

const child = this.child

child.removeAllListeners()

child.kill()

// Wait for the child to exit otherwise its output will be lost which can

// be especially problematic if you're trying to debug why cleanup failed.

await new Promise((r) => child!.on("exit", r))

}

private async relaunch(): Promise<void> {

this.disposeChild()

try {

this.started = this._start()

await this.started

} catch (error: any) {

this.logger.error(error.message)

this.exit(typeof error.code === "number" ? error.code : 1)

}

public start(args: DefaultedArgs): Promise<void> {

// Our logger was created before we parsed CLI arguments so update the level

// in case it has changed.

this.logger.level = logger.level

// Store for relaunches.

this.args = args

if (!this.started) {

this.started = this._start()

}

return this.started

}

private async _start(): Promise<void> {

const child = this.spawn()

this.child = child

// Log child output to stdout/stderr and to the log directory.

if (child.stdout) {

child.stdout.on("data", (data) => {

this.logStdoutStream.write(data)

process.stdout.write(data)

})

}

if (child.stderr) {

child.stderr.on("data", (data) => {

this.logStderrStream.write(data)

process.stderr.write(data)

})

}

this.logger.debug(`spawned child process ${child.pid}`)

await this.handshake(child)

child.once("exit", (code) => {

this.logger.debug(`inner process ${child.pid} exited unexpectedly`)

this.exit(code || 0)

})

}

private spawn(): cp.ChildProcess {

return cp.fork(path.join(__dirname, "entry"), {

env: {

...process.env,

CODE_SERVER_PARENT_PID: process.pid.toString(),

NODE_EXEC_PATH: process.execPath,

stdio: ["pipe", "pipe", "pipe", "ipc"],

})

}

/**

* Wait for a handshake from the child then reply.

private async handshake(child: cp.ChildProcess): Promise<void> {

if (!this.args) {

throw new Error("started without args")

}

const message = await onMessage<ChildMessage, ChildHandshakeMessage>(

child,

(message): message is ChildHandshakeMessage => {

return message.type === "handshake"

this.logger,

)

this.logger.debug("got message", field("message", message))

this.send(child, { type: "handshake", args: this.args })

}

/**

* Send a message to the child.

private send(child: cp.ChildProcess, message: ParentMessage): void {

child.send(message)

}

/**

* Process wrapper.

export const wrapper =

typeof process.env.CODE_SERVER_PARENT_PID !== "undefined"

? new ChildProcess(parseInt(process.env.CODE_SERVER_PARENT_PID))

: new ParentProcess(require("../../package.json").version)

export function isChild(proc: ChildProcess | ParentProcess): proc is ChildProcess {

return proc instanceof ChildProcess

}

// 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", () => wrapper.exit())

}

// Don't let uncaught exceptions crash the process.

process.on("uncaughtException", (error) => {

wrapper.logger.error(`Uncaught exception: ${error.message}`)

if (typeof error.stack !== "undefined") {

wrapper.logger.error(error.stack)

}

})

code-server/src/node/wrapper.ts at v4.102.0 · coder/code-server · GitHub

Uh oh!

Expand file tree

Breadcrumbs

wrapper.ts

Latest commit

History

Breadcrumbs

wrapper.ts

File metadata and controls