Skip to content
Navigation Menu
{{ message }}
forked from coder/code-server
-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathwrapper.ts
More file actions
397 lines (344 loc) · 11 KB
/
Copy pathwrapper.ts
File metadata and controls
397 lines (344 loc) · 11 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
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)
}
})
You can’t perform that action at this time.