diff --git a/package.json b/package.json index 74745f250..523c92f5f 100644 --- a/package.json +++ b/package.json @@ -28,6 +28,7 @@ "mini-css-extract-plugin": "^0.5.0", "node-sass": "^4.11.0", "npm-run-all": "^4.1.5", + "path-browserify": "^1.0.0", "preload-webpack-plugin": "^3.0.0-beta.2", "sass-loader": "^7.1.0", "string-replace-loader": "^2.1.1", @@ -48,6 +49,7 @@ }, "dependencies": { "node-loader": "^0.6.0", + "spdlog": "^0.7.2", "trash": "^4.3.0", "webpack-merge": "^4.2.1" } diff --git a/packages/ide/src/fill/child_process.ts b/packages/ide/src/fill/child_process.ts index a41522084..f99d0ac40 100644 --- a/packages/ide/src/fill/child_process.ts +++ b/packages/ide/src/fill/child_process.ts @@ -1,85 +1,194 @@ import * as cp from "child_process"; -import { Client, useBuffer } from "@coder/protocol"; +import * as net from "net"; +import * as stream from "stream"; +import { CallbackEmitter, ActiveEvalReadable, ActiveEvalWritable, createUniqueEval } from "./evaluation"; import { client } from "./client"; -import { promisify } from "./util"; +import { promisify } from "util"; -class CP { - public constructor( - private readonly client: Client, - ) { } +declare var __non_webpack_require__: typeof require; - public exec = ( - command: string, - options?: { encoding?: BufferEncoding | string | "buffer" | null } & cp.ExecOptions | null | ((error: Error | null, stdout: string, stderr: string) => void) | ((error: Error | null, stdout: Buffer, stderr: Buffer) => void), - callback?: ((error: Error | null, stdout: string, stderr: string) => void) | ((error: Error | null, stdout: Buffer, stderr: Buffer) => void), - ): cp.ChildProcess => { - // TODO: Probably should add an `exec` instead of using `spawn`, especially - // since bash might not be available. - const childProcess = this.client.spawn("bash", ["-c", command.replace(/"/g, "\\\"")]); +class ChildProcess extends CallbackEmitter implements cp.ChildProcess { + private _connected: boolean = false; + private _killed: boolean = false; + private _pid = -1; + public readonly stdin: stream.Writable; + public readonly stdout: stream.Readable; + public readonly stderr: stream.Readable; + // We need the explicit type otherwise TypeScript thinks it is (Writable | Readable)[]. + public readonly stdio: [stream.Writable, stream.Readable, stream.Readable] = [this.stdin, this.stdout, this.stderr]; - let stdout = ""; - childProcess.stdout.on("data", (data) => { - stdout += data.toString(); - }); + // tslint:disable no-any + public constructor(method: "exec", command: string, options?: { encoding?: string | null } & cp.ExecOptions | null, callback?: (...args: any[]) => void); + public constructor(method: "fork", modulePath: string, options?: cp.ForkOptions, args?: string[]); + public constructor(method: "spawn", command: string, options?: cp.SpawnOptions, args?: string[]); + public constructor(method: "exec" | "spawn" | "fork", command: string, options: object = {}, callback?: string[] | ((...args: any[]) => void)) { + // tslint:enable no-any + super(); - let stderr = ""; - childProcess.stderr.on("data", (data) => { - stderr += data.toString(); - }); - - childProcess.on("exit", (exitCode) => { - const error = exitCode !== 0 ? new Error(stderr) : null; - if (typeof options === "function") { - callback = options; - } - if (callback) { - // @ts-ignore not sure how to make this work. - callback( - error, - useBuffer(options) ? Buffer.from(stdout) : stdout, - useBuffer(options) ? Buffer.from(stderr) : stderr, - ); - } - }); - - // @ts-ignore TODO: not fully implemented - return childProcess; - } - - public fork = (modulePath: string, args?: string[] | cp.ForkOptions, options?: cp.ForkOptions): cp.ChildProcess => { - if (options && options.env && options.env.AMD_ENTRYPOINT) { - // @ts-ignore TODO: not fully implemented - return this.client.bootstrapFork( - options.env.AMD_ENTRYPOINT, - Array.isArray(args) ? args : [], - // @ts-ignore TODO: env is a different type - Array.isArray(args) || !args ? options : args, - ); + let args: string[] = []; + if (Array.isArray(callback)) { + args = callback; + callback = undefined; } - // @ts-ignore TODO: not fully implemented - return this.client.fork( - modulePath, - Array.isArray(args) ? args : [], - // @ts-ignore TODO: env is a different type - Array.isArray(args) || !args ? options : args, - ); + this.ae = client.run((ae, command, method, args, options, callbackId) => { + const cp = __non_webpack_require__("child_process") as typeof import("child_process"); + const { maybeCallback, createUniqueEval, bindWritable, bindReadable, preserveEnv } = __non_webpack_require__("@coder/ide/src/fill/evaluation") as typeof import("@coder/ide/src/fill/evaluation"); + + preserveEnv(options); + + let childProcess: cp.ChildProcess; + switch (method) { + case "exec": + childProcess = cp.exec(command, options, maybeCallback(ae, callbackId)); + break; + case "spawn": + childProcess = cp.spawn(command, args, options); + break; + case "fork": + const forkOptions = options as cp.ForkOptions; + if (forkOptions && forkOptions.env && forkOptions.env.AMD_ENTRYPOINT) { + // TODO: This is vscode-specific and should be abstracted. + const { forkModule } = __non_webpack_require__("@coder/server/src/vscode/bootstrapFork") as typeof import ("@coder/server/src/vscode/bootstrapFork"); + childProcess = forkModule(forkOptions.env.AMD_ENTRYPOINT, args, forkOptions); + } else { + childProcess = cp.fork(command, args, options); + } + break; + default: + throw new Error(`invalid method ${method}`); + } + + ae.on("disconnect", () => childProcess.disconnect()); + ae.on("kill", (signal) => childProcess.kill(signal)); + ae.on("ref", () => childProcess.ref()); + ae.on("send", (message, callbackId) => childProcess.send(message, maybeCallback(ae, callbackId))); + ae.on("unref", () => childProcess.unref()); + + ae.emit("pid", childProcess.pid); + childProcess.on("close", (code, signal) => ae.emit("close", code, signal)); + childProcess.on("disconnect", () => ae.emit("disconnect")); + childProcess.on("error", (error) => ae.emit("error", error)); + childProcess.on("exit", (code, signal) => ae.emit("exit", code, signal)); + childProcess.on("message", (message) => ae.emit("message", message)); + + bindWritable(createUniqueEval(ae, "stdin"), childProcess.stdin); + bindReadable(createUniqueEval(ae, "stdout"), childProcess.stdout); + bindReadable(createUniqueEval(ae, "stderr"), childProcess.stderr); + + return { + onDidDispose: (cb): cp.ChildProcess => childProcess.on("close", cb), + dispose: (): void => { + childProcess.kill(); + setTimeout(() => childProcess.kill("SIGKILL"), 5000); // Double tap. + }, + }; + }, command, method, args, options, this.storeCallback(callback)); + + this.ae.on("pid", (pid) => { + this._pid = pid; + this._connected = true; + }); + + this.stdin = new ActiveEvalWritable(createUniqueEval(this.ae, "stdin")); + this.stdout = new ActiveEvalReadable(createUniqueEval(this.ae, "stdout")); + this.stderr = new ActiveEvalReadable(createUniqueEval(this.ae, "stderr")); + + this.ae.on("close", (code, signal) => this.emit("close", code, signal)); + this.ae.on("disconnect", () => this.emit("disconnect")); + this.ae.on("error", (error) => this.emit("error", error)); + this.ae.on("exit", (code, signal) => { + this._connected = false; + this._killed = true; + this.emit("exit", code, signal); + }); + this.ae.on("message", (message) => this.emit("message", message)); } - public spawn = (command: string, args?: string[] | cp.SpawnOptions, options?: cp.SpawnOptions): cp.ChildProcess => { - // @ts-ignore TODO: not fully implemented - return this.client.spawn( - command, - Array.isArray(args) ? args : [], - // @ts-ignore TODO: env is a different type - Array.isArray(args) || !args ? options : args, - ); + public get pid(): number { return this._pid; } + public get connected(): boolean { return this._connected; } + public get killed(): boolean { return this._killed; } + + public kill(): void { this.ae.emit("kill"); } + public disconnect(): void { this.ae.emit("disconnect"); } + public ref(): void { this.ae.emit("ref"); } + public unref(): void { this.ae.emit("unref"); } + + public send( + message: any, // tslint:disable-line no-any to match spec + sendHandle?: net.Socket | net.Server | ((error: Error) => void), + options?: cp.MessageOptions | ((error: Error) => void), + callback?: (error: Error) => void): boolean { + if (typeof sendHandle === "function") { + callback = sendHandle; + sendHandle = undefined; + } else if (typeof options === "function") { + callback = options; + options = undefined; + } + if (sendHandle || options) { + throw new Error("sendHandle and options are not supported"); + } + this.ae.emit("send", message, this.storeCallback(callback)); + + // Unfortunately this will always have to be true since we can't retrieve + // the actual response synchronously. + return true; } } -const fillCp = new CP(client); +class CP { + public readonly ChildProcess = ChildProcess; -// tslint:disable-next-line no-any makes util.promisify return an object -(fillCp as any).exec[promisify.customPromisifyArgs] = ["stdout", "stderr"]; + public exec = ( + command: string, + options?: { encoding?: string | null } & cp.ExecOptions | null | ((error: cp.ExecException | null, stdout: string, stderr: string) => void) | ((error: cp.ExecException | null, stdout: Buffer, stderr: Buffer) => void), + callback?: ((error: cp.ExecException | null, stdout: string, stderr: string) => void) | ((error: cp.ExecException | null, stdout: Buffer, stderr: Buffer) => void), + ): cp.ChildProcess => { + if (typeof options === "function") { + callback = options; + options = undefined; + } + return new ChildProcess("exec", command, options, callback); + } + + public fork = (modulePath: string, args?: string[] | cp.ForkOptions, options?: cp.ForkOptions): cp.ChildProcess => { + if (args && !Array.isArray(args)) { + options = args; + args = undefined; + } + + return new ChildProcess("fork", modulePath, options, args); + } + + public spawn = (command: string, args?: string[] | cp.SpawnOptions, options?: cp.SpawnOptions): cp.ChildProcess => { + if (args && !Array.isArray(args)) { + options = args; + args = undefined; + } + + return new ChildProcess("spawn", command, options, args); + } +} + +const fillCp = new CP(); +// Methods that don't follow the standard callback pattern (an error followed +// by a single result) need to provide a custom promisify function. +Object.defineProperty(fillCp.exec, promisify.custom, { + value: ( + command: string, + options?: { encoding?: string | null } & cp.ExecOptions | null, + ): Promise<{ stdout: string | Buffer, stderr: string | Buffer }> => { + return new Promise((resolve, reject): void => { + fillCp.exec(command, options, (error: cp.ExecException | null, stdout: string | Buffer, stderr: string | Buffer) => { + if (error) { + reject(error); + } else { + resolve({ stdout, stderr }); + } + }); + }); + }, +}); export = fillCp; diff --git a/packages/ide/src/fill/electron.ts b/packages/ide/src/fill/electron.ts index 8181d8b21..a111f053c 100644 --- a/packages/ide/src/fill/electron.ts +++ b/packages/ide/src/fill/electron.ts @@ -6,8 +6,7 @@ import { IKey, Dialog as DialogBox } from "./dialog"; import { clipboard } from "./clipboard"; import { client } from "./client"; -// Use this to get around Webpack inserting our fills. -declare var _require: typeof require; +declare var __non_webpack_require__: typeof require; // tslint:disable-next-line no-any (global as any).getOpenUrls = (): string[] => { @@ -99,7 +98,7 @@ class Clipboard { class Shell { public async moveItemToTrash(path: string): Promise { await client.evaluate((path) => { - const trash = _require("trash") as typeof import("trash"); + const trash = __non_webpack_require__("trash") as typeof import("trash"); return trash(path); }, path); diff --git a/packages/ide/src/fill/evaluation.ts b/packages/ide/src/fill/evaluation.ts new file mode 100644 index 000000000..eeea73568 --- /dev/null +++ b/packages/ide/src/fill/evaluation.ts @@ -0,0 +1,338 @@ +import { SpawnOptions, ForkOptions } from "child_process"; +import { EventEmitter } from "events"; +import { Socket } from "net"; +import { Duplex, Readable, Writable } from "stream"; +import { logger } from "@coder/logger"; +import { ActiveEval, Disposer } from "@coder/protocol"; + +// tslint:disable no-any +/** + * If there is a callback ID, return a function that emits the callback event on + * the active evaluation with that ID and all arguments passed to it. Otherwise, + * return undefined. + */ +export const maybeCallback = (ae: ActiveEval, callbackId?: number): ((...args: any[]) => void) | undefined => { + return typeof callbackId !== "undefined" ? (...args: any[]): void => { + ae.emit("callback", callbackId, ...args); + } : undefined; +}; + +// Some spawn code tries to preserve the env (the debug adapter for +// instance) but the env is mostly blank (since we're in the browser), so +// we'll just always preserve the main process.env here, otherwise it +// won't have access to PATH, etc. +// TODO: An alternative solution would be to send the env to the browser? +export const preserveEnv = (options: SpawnOptions | ForkOptions): void => { + if (options && options.env) { + options.env = { ...process.env, ...options.env }; + } +}; + +/** + * Bind a socket to an active evaluation. + */ +export const bindSocket = (ae: ActiveEval, socket: Socket): Disposer => { + socket.on("connect", () => ae.emit("connect")); + socket.on("lookup", (error, address, family, host) => ae.emit("lookup", error, address, family, host)); + socket.on("timeout", () => ae.emit("timeout")); + + ae.on("connect", (options, callbackId) => socket.connect(options, maybeCallback(ae, callbackId))); + ae.on("ref", () => socket.ref()); + ae.on("setKeepAlive", (enable, initialDelay) => socket.setKeepAlive(enable, initialDelay)); + ae.on("setNoDelay", (noDelay) => socket.setNoDelay(noDelay)); + ae.on("setTimeout", (timeout, callbackId) => socket.setTimeout(timeout, maybeCallback(ae, callbackId))); + ae.on("unref", () => socket.unref()); + + bindReadable(ae, socket); + bindWritable(ae, socket); + + return { + onDidDispose: (cb): Socket => socket.on("close", cb), + dispose: (): void => { + socket.removeAllListeners(); + socket.end(); + socket.destroy(); + socket.unref(); + }, + }; +}; + +/** + * Bind a writable stream to an active evaluation. + */ +export const bindWritable = (ae: ActiveEval, writable: Writable | Duplex): void => { + if (!((writable as Readable).read)) { // To avoid binding twice. + writable.on("close", () => ae.emit("close")); + writable.on("error", (error) => ae.emit("error", error)); + + ae.on("destroy", () => writable.destroy()); + } + + writable.on("drain", () => ae.emit("drain")); + writable.on("finish", () => ae.emit("finish")); + writable.on("pipe", () => ae.emit("pipe")); + writable.on("unpipe", () => ae.emit("unpipe")); + + ae.on("cork", () => writable.cork()); + ae.on("end", (chunk, encoding, callbackId) => writable.end(chunk, encoding, maybeCallback(ae, callbackId))); + ae.on("setDefaultEncoding", (encoding) => writable.setDefaultEncoding(encoding)); + ae.on("uncork", () => writable.uncork()); + // Sockets can pass an fd instead of a callback but streams cannot. + ae.on("write", (chunk, encoding, fd, callbackId) => writable.write(chunk, encoding, maybeCallback(ae, callbackId) || fd)); +}; + +/** + * Bind a readable stream to an active evaluation. + */ +export const bindReadable = (ae: ActiveEval, readable: Readable): void => { + // Streams don't have an argument on close but sockets do. + readable.on("close", (...args: any[]) => ae.emit("close", ...args)); + readable.on("data", (data) => ae.emit("data", data)); + readable.on("end", () => ae.emit("end")); + readable.on("error", (error) => ae.emit("error", error)); + readable.on("readable", () => ae.emit("readable")); + + ae.on("destroy", () => readable.destroy()); + ae.on("pause", () => readable.pause()); + ae.on("push", (chunk, encoding) => readable.push(chunk, encoding)); + ae.on("resume", () => readable.resume()); + ae.on("setEncoding", (encoding) => readable.setEncoding(encoding)); + ae.on("unshift", (chunk) => readable.unshift(chunk)); +}; + +/** + * Wrap an evaluation emitter to make unique events for an item to prevent + * conflicts when it shares that emitter with other items. + */ +export const createUniqueEval = (ae: ActiveEval, id: number | "stdout" | "stderr" | "stdin"): ActiveEval => { + let events = []; + + return { + removeAllListeners: (event?: string): void => { + if (!event) { + events.forEach((e) => ae.removeAllListeners(e)); + events = []; + } else { + const index = events.indexOf(event); + if (index !== -1) { + events.splice(index, 1); + ae.removeAllListeners(`${event}:${id}`); + } + } + }, + emit: (event: string, ...args: any[]): void => { + ae.emit(`${event}:${id}`, ...args); + }, + on: (event: string, cb: (...args: any[]) => void): void => { + if (!events.includes(event)) { + events.push(event); + } + ae.on(`${event}:${id}`, cb); + }, + }; +}; + +/** + * An event emitter that can store callbacks with IDs in a map so we can pass + * them back and forth through an active evaluation using those IDs. + */ +export class CallbackEmitter extends EventEmitter { + private _ae: ActiveEval | undefined; + private callbackId = 0; + private readonly callbacks = new Map(); + + public constructor(ae?: ActiveEval) { + super(); + if (ae) { + this.ae = ae; + } + } + + protected get ae(): ActiveEval { + if (!this._ae) { + throw new Error("trying to access active evaluation before it has been set"); + } + + return this._ae; + } + + protected set ae(ae: ActiveEval) { + if (this._ae) { + throw new Error("cannot override active evaluation"); + } + this._ae = ae; + this.ae.on("callback", (callbackId, ...args: any[]) => this.runCallback(callbackId, ...args)); + } + + /** + * Store the callback and return and ID referencing its location in the map. + */ + protected storeCallback(callback?: Function): number | undefined { + if (!callback) { + return undefined; + } + + const callbackId = this.callbackId++; + this.callbacks.set(callbackId, callback); + + return callbackId; + } + + /** + * Call the function with the specified ID and delete it from the map. + * If the ID is undefined or doesn't exist, nothing happens. + */ + private runCallback(callbackId?: number, ...args: any[]): void { + const callback = typeof callbackId !== "undefined" && this.callbacks.get(callbackId); + if (callback && typeof callbackId !== "undefined") { + this.callbacks.delete(callbackId); + callback(...args); + } + } +} + +/** + * A writable stream over an active evaluation. + */ +export class ActiveEvalWritable extends CallbackEmitter implements Writable { + public constructor(ae: ActiveEval) { + super(ae); + // Streams don't have an argument on close but sockets do. + this.ae.on("close", (...args: any[]) => this.emit("close", ...args)); + this.ae.on("drain", () => this.emit("drain")); + this.ae.on("error", (error) => this.emit("error", error)); + this.ae.on("finish", () => this.emit("finish")); + this.ae.on("pipe", () => logger.warn("pipe is not supported")); + this.ae.on("unpipe", () => logger.warn("unpipe is not supported")); + } + + public get writable(): boolean { throw new Error("not implemented"); } + public get writableHighWaterMark(): number { throw new Error("not implemented"); } + public get writableLength(): number { throw new Error("not implemented"); } + public _write(): void { throw new Error("not implemented"); } + public _destroy(): void { throw new Error("not implemented"); } + public _final(): void { throw new Error("not implemented"); } + public pipe(): T { throw new Error("not implemented"); } + + public cork(): void { this.ae.emit("cork"); } + public destroy(): void { this.ae.emit("destroy"); } + public setDefaultEncoding(encoding: string): this { + this.ae.emit("setDefaultEncoding", encoding); + + return this; + } + public uncork(): void { this.ae.emit("uncork"); } + + public write(chunk: any, encoding?: string | ((error?: Error | null) => void), callback?: (error?: Error | null) => void): boolean { + if (typeof encoding === "function") { + callback = encoding; + encoding = undefined; + } + + // Sockets can pass an fd instead of a callback but streams cannot.. + this.ae.emit("write", chunk, encoding, undefined, this.storeCallback(callback)); + + // Always true since we can't get this synchronously. + return true; + } + + public end(data?: any, encoding?: string | Function, callback?: Function): void { + if (typeof encoding === "function") { + callback = encoding; + encoding = undefined; + } + this.ae.emit("end", data, encoding, this.storeCallback(callback)); + } +} + +/** + * A readable stream over an active evaluation. + */ +export class ActiveEvalReadable extends CallbackEmitter implements Readable { + public constructor(ae: ActiveEval) { + super(ae); + this.ae.on("close", () => this.emit("close")); + this.ae.on("data", (data) => this.emit("data", data)); + this.ae.on("end", () => this.emit("end")); + this.ae.on("error", (error) => this.emit("error", error)); + this.ae.on("readable", () => this.emit("readable")); + } + + public get readable(): boolean { throw new Error("not implemented"); } + public get readableHighWaterMark(): number { throw new Error("not implemented"); } + public get readableLength(): number { throw new Error("not implemented"); } + public _read(): void { throw new Error("not implemented"); } + public read(): any { throw new Error("not implemented"); } + public isPaused(): boolean { throw new Error("not implemented"); } + public pipe(): T { throw new Error("not implemented"); } + public unpipe(): this { throw new Error("not implemented"); } + public unshift(): this { throw new Error("not implemented"); } + public wrap(): this { throw new Error("not implemented"); } + public push(): boolean { throw new Error("not implemented"); } + public _destroy(): void { throw new Error("not implemented"); } + public [Symbol.asyncIterator](): AsyncIterableIterator { throw new Error("not implemented"); } + + public destroy(): void { this.ae.emit("destroy"); } + public pause(): this { return this.emitReturnThis("pause"); } + public resume(): this { return this.emitReturnThis("resume"); } + public setEncoding(encoding?: string): this { return this.emitReturnThis("setEncoding", encoding); } + + // tslint:disable-next-line no-any + protected emitReturnThis(event: string, ...args: any[]): this { + this.ae.emit(event, ...args); + + return this; + } +} + +/** + * An duplex stream over an active evaluation. + */ +export class ActiveEvalDuplex extends ActiveEvalReadable implements Duplex { + // Some unfortunate duplication here since we can't have multiple extends. + public constructor(ae: ActiveEval) { + super(ae); + this.ae.on("drain", () => this.emit("drain")); + this.ae.on("finish", () => this.emit("finish")); + this.ae.on("pipe", () => logger.warn("pipe is not supported")); + this.ae.on("unpipe", () => logger.warn("unpipe is not supported")); + } + + public get writable(): boolean { throw new Error("not implemented"); } + public get writableHighWaterMark(): number { throw new Error("not implemented"); } + public get writableLength(): number { throw new Error("not implemented"); } + public _write(): void { throw new Error("not implemented"); } + public _destroy(): void { throw new Error("not implemented"); } + public _final(): void { throw new Error("not implemented"); } + public pipe(): T { throw new Error("not implemented"); } + + public cork(): void { this.ae.emit("cork"); } + public destroy(): void { this.ae.emit("destroy"); } + public setDefaultEncoding(encoding: string): this { + this.ae.emit("setDefaultEncoding", encoding); + + return this; + } + public uncork(): void { this.ae.emit("uncork"); } + + public write(chunk: any, encoding?: string | ((error?: Error | null) => void), callback?: (error?: Error | null) => void): boolean { + if (typeof encoding === "function") { + callback = encoding; + encoding = undefined; + } + + // Sockets can pass an fd instead of a callback but streams cannot.. + this.ae.emit("write", chunk, encoding, undefined, this.storeCallback(callback)); + + // Always true since we can't get this synchronously. + return true; + } + + public end(data?: any, encoding?: string | Function, callback?: Function): void { + if (typeof encoding === "function") { + callback = encoding; + encoding = undefined; + } + this.ae.emit("end", data, encoding, this.storeCallback(callback)); + } +} diff --git a/packages/ide/src/fill/fs.ts b/packages/ide/src/fill/fs.ts index b17ac9819..b3220282f 100644 --- a/packages/ide/src/fill/fs.ts +++ b/packages/ide/src/fill/fs.ts @@ -1,13 +1,11 @@ -import { exec, ChildProcess } from "child_process"; import { EventEmitter } from "events"; import * as fs from "fs"; import * as stream from "stream"; -import { Client, IEncodingOptions, IEncodingOptionsCallback, escapePath, useBuffer } from "@coder/protocol"; +import { Client, IEncodingOptions, IEncodingOptionsCallback } from "@coder/protocol"; import { client } from "./client"; +import { promisify } from "util"; -// Use this to get around Webpack inserting our fills. -// TODO: is there a better way? -declare var _require: typeof require; +declare var __non_webpack_require__: typeof require; declare var _Buffer: typeof Buffer; /** @@ -29,8 +27,8 @@ class FS { mode = undefined; } this.client.evaluate((path, mode) => { - const fs = _require("fs") as typeof import("fs"); - const util = _require("util") as typeof import("util"); + const fs = __non_webpack_require__("fs") as typeof import("fs"); + const util = __non_webpack_require__("util") as typeof import("util"); return util.promisify(fs.access)(path, mode); }, path, mode).then(() => { @@ -47,8 +45,8 @@ class FS { options = undefined; } this.client.evaluate((path, data, options) => { - const fs = _require("fs") as typeof import("fs"); - const util = _require("util") as typeof import("util"); + const fs = __non_webpack_require__("fs") as typeof import("fs"); + const util = __non_webpack_require__("util") as typeof import("util"); return util.promisify(fs.appendFile)(path, data, options); }, file, data, options).then(() => { @@ -60,8 +58,8 @@ class FS { public chmod = (path: fs.PathLike, mode: string | number, callback: (err: NodeJS.ErrnoException) => void): void => { this.client.evaluate((path, mode) => { - const fs = _require("fs") as typeof import("fs"); - const util = _require("util") as typeof import("util"); + const fs = __non_webpack_require__("fs") as typeof import("fs"); + const util = __non_webpack_require__("util") as typeof import("util"); return util.promisify(fs.chmod)(path, mode); }, path, mode).then(() => { @@ -73,8 +71,8 @@ class FS { public chown = (path: fs.PathLike, uid: number, gid: number, callback: (err: NodeJS.ErrnoException) => void): void => { this.client.evaluate((path, uid, gid) => { - const fs = _require("fs") as typeof import("fs"); - const util = _require("util") as typeof import("util"); + const fs = __non_webpack_require__("fs") as typeof import("fs"); + const util = __non_webpack_require__("util") as typeof import("util"); return util.promisify(fs.chown)(path, uid, gid); }, path, uid, gid).then(() => { @@ -86,8 +84,8 @@ class FS { public close = (fd: number, callback: (err: NodeJS.ErrnoException) => void): void => { this.client.evaluate((fd) => { - const fs = _require("fs") as typeof import("fs"); - const util = _require("util") as typeof import("util"); + const fs = __non_webpack_require__("fs") as typeof import("fs"); + const util = __non_webpack_require__("util") as typeof import("util"); return util.promisify(fs.close)(fd); }, fd).then(() => { @@ -102,8 +100,8 @@ class FS { callback = flags; } this.client.evaluate((src, dest, flags) => { - const fs = _require("fs") as typeof import("fs"); - const util = _require("util") as typeof import("util"); + const fs = __non_webpack_require__("fs") as typeof import("fs"); + const util = __non_webpack_require__("util") as typeof import("util"); return util.promisify(fs.copyFile)(src, dest, flags); }, src, dest, typeof flags !== "function" ? flags : undefined).then(() => { @@ -113,19 +111,21 @@ class FS { }); } - /** - * This should NOT be used for long-term writes. - * The runnable will be killed after the timeout specified in evaluate.ts - */ + // tslint:disable-next-line no-any public createWriteStream = (path: fs.PathLike, options?: any): fs.WriteStream => { const ae = this.client.run((ae, path, options) => { - const fs = _require("fs") as typeof import("fs"); + const fs = __non_webpack_require__("fs") as typeof import("fs"); const str = fs.createWriteStream(path, options); - ae.on("write", (d, e) => str.write(_Buffer.from(d, "utf8"))); + ae.on("write", (d) => str.write(_Buffer.from(d, "utf8"))); ae.on("close", () => str.close()); str.on("close", () => ae.emit("close")); str.on("open", (fd) => ae.emit("open", fd)); str.on("error", (err) => ae.emit(err)); + + return { + onDidDispose: (cb): fs.WriteStream => str.on("close", cb), + dispose: (): void => str.close(), + }; }, path, options); return new (class WriteStream extends stream.Writable implements fs.WriteStream { @@ -134,7 +134,7 @@ class FS { public constructor() { super({ - write: (data, encoding, cb) => { + write: (data, encoding, cb): void => { this._bytesWritten += data.length; ae.emit("write", Buffer.from(data, encoding), encoding); cb(); @@ -162,8 +162,8 @@ class FS { public exists = (path: fs.PathLike, callback: (exists: boolean) => void): void => { this.client.evaluate((path) => { - const fs = _require("fs") as typeof import("fs"); - const util = _require("util") as typeof import("util"); + const fs = __non_webpack_require__("fs") as typeof import("fs"); + const util = __non_webpack_require__("util") as typeof import("util"); return util.promisify(fs.exists)(path); }, path).then((r) => { @@ -175,8 +175,8 @@ class FS { public fchmod = (fd: number, mode: string | number, callback: (err: NodeJS.ErrnoException) => void): void => { this.client.evaluate((fd, mode) => { - const fs = _require("fs") as typeof import("fs"); - const util = _require("util") as typeof import("util"); + const fs = __non_webpack_require__("fs") as typeof import("fs"); + const util = __non_webpack_require__("util") as typeof import("util"); return util.promisify(fs.fchmod)(fd, mode); }, fd, mode).then(() => { @@ -188,8 +188,8 @@ class FS { public fchown = (fd: number, uid: number, gid: number, callback: (err: NodeJS.ErrnoException) => void): void => { this.client.evaluate((fd, uid, gid) => { - const fs = _require("fs") as typeof import("fs"); - const util = _require("util") as typeof import("util"); + const fs = __non_webpack_require__("fs") as typeof import("fs"); + const util = __non_webpack_require__("util") as typeof import("util"); return util.promisify(fs.fchown)(fd, uid, gid); }, fd, uid, gid).then(() => { @@ -201,8 +201,8 @@ class FS { public fdatasync = (fd: number, callback: (err: NodeJS.ErrnoException) => void): void => { this.client.evaluate((fd) => { - const fs = _require("fs") as typeof import("fs"); - const util = _require("util") as typeof import("util"); + const fs = __non_webpack_require__("fs") as typeof import("fs"); + const util = __non_webpack_require__("util") as typeof import("util"); return util.promisify(fs.fdatasync)(fd); }, fd).then(() => { @@ -214,9 +214,9 @@ class FS { public fstat = (fd: number, callback: (err: NodeJS.ErrnoException, stats: fs.Stats) => void): void => { this.client.evaluate((fd) => { - const fs = _require("fs") as typeof import("fs"); - const util = _require("util") as typeof import("util"); - const tslib = _require("tslib") as typeof import("tslib"); + const fs = __non_webpack_require__("fs") as typeof import("fs"); + const util = __non_webpack_require__("util") as typeof import("util"); + const tslib = __non_webpack_require__("tslib") as typeof import("tslib"); return util.promisify(fs.fstat)(fd).then((stats) => { return tslib.__assign(stats, { @@ -238,8 +238,8 @@ class FS { public fsync = (fd: number, callback: (err: NodeJS.ErrnoException) => void): void => { this.client.evaluate((fd) => { - const fs = _require("fs") as typeof import("fs"); - const util = _require("util") as typeof import("util"); + const fs = __non_webpack_require__("fs") as typeof import("fs"); + const util = __non_webpack_require__("util") as typeof import("util"); return util.promisify(fs.fsync)(fd); }, fd).then(() => { @@ -255,8 +255,8 @@ class FS { len = undefined; } this.client.evaluate((fd, len) => { - const fs = _require("fs") as typeof import("fs"); - const util = _require("util") as typeof import("util"); + const fs = __non_webpack_require__("fs") as typeof import("fs"); + const util = __non_webpack_require__("util") as typeof import("util"); return util.promisify(fs.ftruncate)(fd, len); }, fd, len).then(() => { @@ -268,8 +268,8 @@ class FS { public futimes = (fd: number, atime: string | number | Date, mtime: string | number | Date, callback: (err: NodeJS.ErrnoException) => void): void => { this.client.evaluate((fd, atime, mtime) => { - const fs = _require("fs") as typeof import("fs"); - const util = _require("util") as typeof import("util"); + const fs = __non_webpack_require__("fs") as typeof import("fs"); + const util = __non_webpack_require__("util") as typeof import("util"); return util.promisify(fs.futimes)(fd, atime, mtime); }, fd, atime, mtime).then(() => { @@ -281,8 +281,8 @@ class FS { public lchmod = (path: fs.PathLike, mode: string | number, callback: (err: NodeJS.ErrnoException) => void): void => { this.client.evaluate((path, mode) => { - const fs = _require("fs") as typeof import("fs"); - const util = _require("util") as typeof import("util"); + const fs = __non_webpack_require__("fs") as typeof import("fs"); + const util = __non_webpack_require__("util") as typeof import("util"); return util.promisify(fs.lchmod)(path, mode); }, path, mode).then(() => { @@ -294,8 +294,8 @@ class FS { public lchown = (path: fs.PathLike, uid: number, gid: number, callback: (err: NodeJS.ErrnoException) => void): void => { this.client.evaluate((path, uid, gid) => { - const fs = _require("fs") as typeof import("fs"); - const util = _require("util") as typeof import("util"); + const fs = __non_webpack_require__("fs") as typeof import("fs"); + const util = __non_webpack_require__("util") as typeof import("util"); return util.promisify(fs.lchown)(path, uid, gid); }, path, uid, gid).then(() => { @@ -307,8 +307,8 @@ class FS { public link = (existingPath: fs.PathLike, newPath: fs.PathLike, callback: (err: NodeJS.ErrnoException) => void): void => { this.client.evaluate((existingPath, newPath) => { - const fs = _require("fs") as typeof import("fs"); - const util = _require("util") as typeof import("util"); + const fs = __non_webpack_require__("fs") as typeof import("fs"); + const util = __non_webpack_require__("util") as typeof import("util"); return util.promisify(fs.link)(existingPath, newPath); }, existingPath, newPath).then(() => { @@ -320,9 +320,9 @@ class FS { public lstat = (path: fs.PathLike, callback: (err: NodeJS.ErrnoException, stats: fs.Stats) => void): void => { this.client.evaluate((path) => { - const fs = _require("fs") as typeof import("fs"); - const util = _require("util") as typeof import("util"); - const tslib = _require("tslib") as typeof import("tslib"); + const fs = __non_webpack_require__("fs") as typeof import("fs"); + const util = __non_webpack_require__("util") as typeof import("util"); + const tslib = __non_webpack_require__("tslib") as typeof import("tslib"); return util.promisify(fs.lstat)(path).then((stats) => { return tslib.__assign(stats, { @@ -348,8 +348,8 @@ class FS { mode = undefined; } this.client.evaluate((path, mode) => { - const fs = _require("fs") as typeof import("fs"); - const util = _require("util") as typeof import("util"); + const fs = __non_webpack_require__("fs") as typeof import("fs"); + const util = __non_webpack_require__("util") as typeof import("util"); return util.promisify(fs.mkdir)(path, mode); }, path, mode).then(() => { @@ -365,8 +365,8 @@ class FS { options = undefined; } this.client.evaluate((prefix, options) => { - const fs = _require("fs") as typeof import("fs"); - const util = _require("util") as typeof import("util"); + const fs = __non_webpack_require__("fs") as typeof import("fs"); + const util = __non_webpack_require__("util") as typeof import("util"); return util.promisify(fs.mkdtemp)(prefix, options); }, prefix, options).then((folder) => { @@ -382,8 +382,8 @@ class FS { mode = undefined; } this.client.evaluate((path, flags, mode) => { - const fs = _require("fs") as typeof import("fs"); - const util = _require("util") as typeof import("util"); + const fs = __non_webpack_require__("fs") as typeof import("fs"); + const util = __non_webpack_require__("util") as typeof import("util"); return util.promisify(fs.open)(path, flags, mode); }, path, flags, mode).then((fd) => { @@ -395,8 +395,8 @@ class FS { public read = (fd: number, buffer: TBuffer, offset: number, length: number, position: number | null, callback: (err: NodeJS.ErrnoException, bytesRead: number, buffer: TBuffer) => void): void => { this.client.evaluate((fd, length, position) => { - const fs = _require("fs") as typeof import("fs"); - const util = _require("util") as typeof import("util"); + const fs = __non_webpack_require__("fs") as typeof import("fs"); + const util = __non_webpack_require__("util") as typeof import("util"); const buffer = new _Buffer(length); return util.promisify(fs.read)(fd, buffer, 0, length, position).then((resp) => { @@ -420,8 +420,8 @@ class FS { options = undefined; } this.client.evaluate((path, options) => { - const fs = _require("fs") as typeof import("fs"); - const util = _require("util") as typeof import("util"); + const fs = __non_webpack_require__("fs") as typeof import("fs"); + const util = __non_webpack_require__("util") as typeof import("util"); return util.promisify(fs.readFile)(path, options).then((value) => value.toString()); }, path, options).then((buffer) => { @@ -438,8 +438,8 @@ class FS { } // TODO: options can also take `withFileTypes` but the types aren't working. this.client.evaluate((path, options) => { - const fs = _require("fs") as typeof import("fs"); - const util = _require("util") as typeof import("util"); + const fs = __non_webpack_require__("fs") as typeof import("fs"); + const util = __non_webpack_require__("util") as typeof import("util"); return util.promisify(fs.readdir)(path, options); }, path, options).then((files) => { @@ -455,8 +455,8 @@ class FS { options = undefined; } this.client.evaluate((path, options) => { - const fs = _require("fs") as typeof import("fs"); - const util = _require("util") as typeof import("util"); + const fs = __non_webpack_require__("fs") as typeof import("fs"); + const util = __non_webpack_require__("util") as typeof import("util"); return util.promisify(fs.readlink)(path, options); }, path, options).then((linkString) => { @@ -472,8 +472,8 @@ class FS { options = undefined; } this.client.evaluate((path, options) => { - const fs = _require("fs") as typeof import("fs"); - const util = _require("util") as typeof import("util"); + const fs = __non_webpack_require__("fs") as typeof import("fs"); + const util = __non_webpack_require__("util") as typeof import("util"); return util.promisify(fs.realpath)(path, options); }, path, options).then((resolvedPath) => { @@ -485,8 +485,8 @@ class FS { public rename = (oldPath: fs.PathLike, newPath: fs.PathLike, callback: (err: NodeJS.ErrnoException) => void): void => { this.client.evaluate((oldPath, newPath) => { - const fs = _require("fs") as typeof import("fs"); - const util = _require("util") as typeof import("util"); + const fs = __non_webpack_require__("fs") as typeof import("fs"); + const util = __non_webpack_require__("util") as typeof import("util"); return util.promisify(fs.rename)(oldPath, newPath); }, oldPath, newPath).then(() => { @@ -498,8 +498,8 @@ class FS { public rmdir = (path: fs.PathLike, callback: (err: NodeJS.ErrnoException) => void): void => { this.client.evaluate((path) => { - const fs = _require("fs") as typeof import("fs"); - const util = _require("util") as typeof import("util"); + const fs = __non_webpack_require__("fs") as typeof import("fs"); + const util = __non_webpack_require__("util") as typeof import("util"); return util.promisify(fs.rmdir)(path); }, path).then(() => { @@ -511,9 +511,9 @@ class FS { public stat = (path: fs.PathLike, callback: (err: NodeJS.ErrnoException, stats: fs.Stats) => void): void => { this.client.evaluate((path) => { - const fs = _require("fs") as typeof import("fs"); - const util = _require("util") as typeof import("util"); - const tslib = _require("tslib") as typeof import("tslib"); + const fs = __non_webpack_require__("fs") as typeof import("fs"); + const util = __non_webpack_require__("util") as typeof import("util"); + const tslib = __non_webpack_require__("tslib") as typeof import("tslib"); return util.promisify(fs.stat)(path).then((stats) => { return tslib.__assign(stats, { @@ -543,8 +543,8 @@ class FS { type = undefined; } this.client.evaluate((target, path, type) => { - const fs = _require("fs") as typeof import("fs"); - const util = _require("util") as typeof import("util"); + const fs = __non_webpack_require__("fs") as typeof import("fs"); + const util = __non_webpack_require__("util") as typeof import("util"); return util.promisify(fs.symlink)(target, path, type); }, target, path, type).then(() => { @@ -560,8 +560,8 @@ class FS { len = undefined; } this.client.evaluate((path, len) => { - const fs = _require("fs") as typeof import("fs"); - const util = _require("util") as typeof import("util"); + const fs = __non_webpack_require__("fs") as typeof import("fs"); + const util = __non_webpack_require__("util") as typeof import("util"); return util.promisify(fs.truncate)(path, len); }, path, len).then(() => { @@ -573,8 +573,8 @@ class FS { public unlink = (path: fs.PathLike, callback: (err: NodeJS.ErrnoException) => void): void => { this.client.evaluate((path) => { - const fs = _require("fs") as typeof import("fs"); - const util = _require("util") as typeof import("util"); + const fs = __non_webpack_require__("fs") as typeof import("fs"); + const util = __non_webpack_require__("util") as typeof import("util"); return util.promisify(fs.unlink)(path); }, path).then(() => { @@ -586,8 +586,8 @@ class FS { public utimes = (path: fs.PathLike, atime: string | number | Date, mtime: string | number | Date, callback: (err: NodeJS.ErrnoException) => void): void => { this.client.evaluate((path, atime, mtime) => { - const fs = _require("fs") as typeof import("fs"); - const util = _require("util") as typeof import("util"); + const fs = __non_webpack_require__("fs") as typeof import("fs"); + const util = __non_webpack_require__("util") as typeof import("util"); return util.promisify(fs.utimes)(path, atime, mtime); }, path, atime, mtime).then(() => { @@ -603,8 +603,8 @@ class FS { position = undefined; } this.client.evaluate((fd, buffer, offset, length, position) => { - const fs = _require("fs") as typeof import("fs"); - const util = _require("util") as typeof import("util"); + const fs = __non_webpack_require__("fs") as typeof import("fs"); + const util = __non_webpack_require__("util") as typeof import("util"); return util.promisify(fs.write)(fd, _Buffer.from(buffer, "utf8"), offset, length, position).then((resp) => { return { @@ -626,8 +626,8 @@ class FS { options = undefined; } this.client.evaluate((path, data, options) => { - const fs = _require("fs") as typeof import("fs"); - const util = _require("util") as typeof import("util"); + const fs = __non_webpack_require__("fs") as typeof import("fs"); + const util = __non_webpack_require__("util") as typeof import("util"); return util.promisify(fs.writeFile)(path, data, options); }, path, data, options).then(() => { @@ -637,63 +637,40 @@ class FS { }); } - public watch = (filename: fs.PathLike, options: IEncodingOptions, listener?: ((event: string, filename: string) => void) | ((event: string, filename: Buffer) => void)): fs.FSWatcher => { - // TODO: can we modify `evaluate` for long-running processes like watch? - // Especially since inotifywait might not be available. - const buffer = new NewlineInputBuffer((msg): void => { - msg = msg.trim(); - const index = msg.lastIndexOf(":"); - const events = msg.substring(index + 1).split(","); - const baseFilename = msg.substring(0, index).split("/").pop(); - events.forEach((event) => { - switch (event) { - // Rename is emitted when a file appears or disappears in the directory. - case "CREATE": - case "DELETE": - case "MOVED_FROM": - case "MOVED_TO": - watcher.emit("rename", baseFilename); - break; - case "CLOSE_WRITE": - watcher.emit("change", baseFilename); - break; - } - }); - }); - - // TODO: `exec` is undefined for some reason. - const process = exec(`inotifywait ${escapePath(filename.toString())} -m --format "%w%f:%e"`); - process.on("exit", (exitCode) => { - watcher.emit("error", new Error(`process terminated unexpectedly with code ${exitCode}`)); - }); - process.stdout.on("data", (data) => { - buffer.push(data); - }); - - const watcher = new Watcher(process); - if (listener) { - const l = listener; - watcher.on("change", (filename) => { - // @ts-ignore not sure how to make this work. - l("change", useBuffer(options) ? Buffer.from(filename) : filename); - }); - watcher.on("rename", (filename) => { - // @ts-ignore not sure how to make this work. - l("rename", useBuffer(options) ? Buffer.from(filename) : filename); - }); + public watch = (filename: fs.PathLike, options?: IEncodingOptions | ((event: string, filename: string | Buffer) => void), listener?: ((event: string, filename: string | Buffer) => void)): fs.FSWatcher => { + if (typeof options === "function") { + listener = options; + options = undefined; } - return watcher; - } -} + const ae = this.client.run((ae, filename, hasListener, options) => { + const fs = __non_webpack_require__("fs") as typeof import ("fs"); + // tslint:disable-next-line no-any + const watcher = fs.watch(filename, options as any, hasListener ? (event, filename): void => { + ae.emit("listener", event, filename); + } : undefined); + watcher.on("change", (event, filename) => ae.emit("change", event, filename)); + watcher.on("error", (error) => ae.emit("error", error)); + ae.on("close", () => watcher.close()); -class Watcher extends EventEmitter implements fs.FSWatcher { - public constructor(private readonly process: ChildProcess) { - super(); - } + return { + onDidDispose: (cb): void => ae.on("close", cb), + dispose: (): void => watcher.close(), + }; + }, filename.toString(), !!listener, options); - public close(): void { - this.process.kill(); + return new class Watcher extends EventEmitter implements fs.FSWatcher { + public constructor() { + super(); + ae.on("change", (event, filename) => this.emit("change", event, filename)); + ae.on("error", (error) => this.emit("error", error)); + ae.on("listener", (event, filename) => listener && listener(event, filename)); + } + + public close(): void { + ae.emit("close"); + } + }; } } @@ -765,38 +742,10 @@ class Stats implements fs.Stats { } } -/** - * Class for safely taking input and turning it into separate messages. - * Assumes that messages are split by newlines. - */ -class NewlineInputBuffer { - private callback: (msg: string) => void; - private buffer: string | undefined; - - public constructor(callback: (msg: string) => void) { - this.callback = callback; - } - - /** - * Add data to be buffered. - */ - public push(data: string | Uint8Array): void { - let input = typeof data === "string" ? data : data.toString(); - if (this.buffer) { - input = this.buffer + input; - this.buffer = undefined; - } - const lines = input.split("\n"); - const length = lines.length - 1; - const lastLine = lines[length]; - if (lastLine.length > 0) { - this.buffer = lastLine; - } - lines.pop(); // This is either the line we buffered or an empty string. - for (let i = 0; i < length; ++i) { - this.callback(lines[i]); - } - } -} - -export = new FS(client); +const fillFs = new FS(client); +// Methods that don't follow the standard callback pattern (an error followed +// by a single result) need to provide a custom promisify function. +Object.defineProperty(fillFs.exists, promisify.custom, { + value: (path: fs.PathLike): Promise => new Promise((resolve): void => fillFs.exists(path, resolve)), +}); +export = fillFs; diff --git a/packages/ide/src/fill/net.ts b/packages/ide/src/fill/net.ts index 92af470bb..7a8e5b7af 100644 --- a/packages/ide/src/fill/net.ts +++ b/packages/ide/src/fill/net.ts @@ -1,55 +1,256 @@ import * as net from "net"; -import { Client } from "@coder/protocol"; +import { ActiveEval } from "@coder/protocol"; +import { CallbackEmitter, ActiveEvalDuplex, createUniqueEval } from "./evaluation"; import { client } from "./client"; +declare var __non_webpack_require__: typeof require; + +class Socket extends ActiveEvalDuplex implements net.Socket { + private _connecting: boolean = false; + private _destroyed: boolean = false; + + public constructor(options?: net.SocketConstructorOpts, ae?: ActiveEval) { + super(ae || client.run((ae, options) => { + const net = __non_webpack_require__("net") as typeof import("net"); + const { bindSocket } = __non_webpack_require__("@coder/ide/src/fill/evaluation") as typeof import("@coder/ide/src/fill/evaluation"); + + return bindSocket(ae, new net.Socket(options)); + }, options)); + + this.ae.on("connect", () => { + this._connecting = false; + this.emit("connect"); + }); + this.ae.on("error", () => { + this._connecting = false; + this._destroyed = true; + }); + this.ae.on("lookup", (error, address, family, host) => this.emit("lookup", error, address, family, host)); + this.ae.on("timeout", () => this.emit("timeout")); + } + + public connect(options: net.SocketConnectOpts | number | string, host?: string | Function, connectionListener?: Function): this { + // This is to get around type issues with socket.connect as well as extract + // the function wherever it might be. + switch (typeof options) { + case "string": options = { path: options }; break; + case "number": options = { port: options }; break; + } + switch (typeof host) { + case "function": connectionListener = host; break; + case "string": (options as net.TcpSocketConnectOpts).host = host; break; + } + + this._connecting = true; + this.ae.emit("connect", options, this.storeCallback(connectionListener)); + + return this; + } + + // tslint:disable-next-line no-any + public write(data: any, encoding?: string | Function, fd?: string | Function): boolean { + let callback: Function | undefined; + if (typeof encoding === "function") { + callback = encoding; + encoding = undefined; + } + if (typeof fd === "function") { + callback = fd; + fd = undefined; + } + this.ae.emit("write", data, encoding, fd, this.storeCallback(callback)); + + return true; // Always true since we can't get this synchronously. + } + + public get connecting(): boolean { return this._connecting; } + public get destroyed(): boolean { return this._destroyed; } + + public get bufferSize(): number { throw new Error("not implemented"); } + public get bytesRead(): number { throw new Error("not implemented"); } + public get bytesWritten(): number { throw new Error("not implemented"); } + public get localAddress(): string { throw new Error("not implemented"); } + public get localPort(): number { throw new Error("not implemented"); } + public address(): net.AddressInfo | string { throw new Error("not implemented"); } + + public setTimeout(timeout: number, callback?: Function): this { return this.emitReturnThis("setTimeout", timeout, this.storeCallback(callback)); } + public setNoDelay(noDelay?: boolean): this { return this.emitReturnThis("setNoDelay", noDelay); } + public setKeepAlive(enable?: boolean, initialDelay?: number): this { return this.emitReturnThis("setKeepAlive", enable, initialDelay); } + public unref(): void { this.ae.emit("unref"); } + public ref(): void { this.ae.emit("ref"); } +} + +class Server extends CallbackEmitter implements net.Server { + private readonly sockets = new Map(); + private _listening: boolean = false; + + public constructor(options?: { allowHalfOpen?: boolean, pauseOnConnect?: boolean } | ((socket: Socket) => void), connectionListener?: (socket: Socket) => void) { + super(); + + if (typeof options === "function") { + connectionListener = options; + options = undefined; + } + + this.ae = client.run((ae, options, callbackId) => { + const net = __non_webpack_require__("net") as typeof import("net"); + const { maybeCallback, bindSocket, createUniqueEval } = __non_webpack_require__("@coder/ide/src/fill/evaluation") as typeof import("@coder/ide/src/fill/evaluation"); + + let connectionId = 0; + let server = new net.Server(options, maybeCallback(ae, callbackId)); + const sockets = new Map(); + + const storeSocket = (socket: net.Socket): number => { + const socketId = connectionId++; + sockets.set(socketId, socket); + const disposer = bindSocket(createUniqueEval(ae, socketId), socket); + socket.on("close", () => { + disposer.dispose(); + sockets.delete(socketId); + }); + + return socketId; + }; + + server.on("close", () => ae.emit("close")); + server.on("connection", (socket) => ae.emit("connection", storeSocket(socket))); + server.on("error", (error) => ae.emit("error", error)); + server.on("listening", () => ae.emit("listening")); + + ae.on("close", (callbackId) => server.close(maybeCallback(ae, callbackId))); + ae.on("listen", (handle) => server.listen(handle)); + ae.on("ref", () => server.ref()); + ae.on("unref", () => server.unref()); + + return { + onDidDispose: (cb): net.Server => server.on("close", cb), + dispose: (): void => { + server.removeAllListeners(); + server.close(); + sockets.forEach((socket) => { + socket.removeAllListeners(); + socket.end(); + socket.destroy(); + socket.unref(); + }); + sockets.clear(); + }, + }; + }, options, this.storeCallback(connectionListener)); + + this.ae.on("close", () => { + this._listening = false; + this.emit("close"); + }); + + this.ae.on("connection", (socketId) => { + const socket = new Socket(undefined, createUniqueEval(this.ae, socketId)); + this.sockets.set(socketId, socket); + socket.on("close", () => this.sockets.delete(socketId)); + if (connectionListener) { + connectionListener(socket); + } + this.emit("connection", socket); + }); + + this.ae.on("error", (error) => { + this._listening = false; + this.emit("error", error); + }); + + this.ae.on("listening", () => { + this._listening = true; + this.emit("listening"); + }); + } + + public listen(handle?: net.ListenOptions | number | string, hostname?: string | number | Function, backlog?: number | Function, listeningListener?: Function): this { + if (typeof handle === "undefined") { + throw new Error("no handle"); + } + + switch (typeof handle) { + case "number": handle = { port: handle }; break; + case "string": handle = { path: handle }; break; + } + switch (typeof hostname) { + case "function": listeningListener = hostname; break; + case "string": handle.host = hostname; break; + case "number": handle.backlog = hostname; break; + } + switch (typeof backlog) { + case "function": listeningListener = backlog; break; + case "number": handle.backlog = backlog; break; + } + + if (listeningListener) { + this.ae.on("listening", () => { + listeningListener!(); + }); + } + + this.ae.emit("listen", handle); + + return this; + } + + public close(callback?: Function): this { + // close() doesn't fire the close event until all connections are also + // closed, but it does prevent new connections. + this._listening = false; + this.ae.emit("close", this.storeCallback(callback)); + + return this; + } + + public get connections(): number { return this.sockets.size; } + public get listening(): boolean { return this._listening; } + + public get maxConnections(): number { throw new Error("not implemented"); } + public address(): net.AddressInfo | string { throw new Error("not implemented"); } + + public ref(): this { return this.emitReturnThis("ref"); } + public unref(): this { return this.emitReturnThis("unref"); } + public getConnections(cb: (error: Error | null, count: number) => void): void { cb(null, this.sockets.size); } + + // tslint:disable-next-line no-any + private emitReturnThis(event: string, ...args: any[]): this { + this.ae.emit(event, ...args); + + return this; + } +} + type NodeNet = typeof net; /** * Implementation of net for the browser. */ class Net implements NodeNet { - public constructor( - private readonly client: Client, - ) {} - - public get Socket(): typeof net.Socket { - return this.client.Socket; - } - - public get Server(): typeof net.Server { - throw new Error("not implemented"); - } - - public connect(): net.Socket { - throw new Error("not implemented"); - } + // @ts-ignore this is because Socket is missing things from the Stream + // namespace but I'm unsure how best to provide them (finished, + // finished.__promisify__, pipeline, and some others) or if it even matters. + public readonly Socket = Socket; + public readonly Server = Server; public createConnection(target: string | number | net.NetConnectOpts, host?: string | Function, callback?: Function): net.Socket { - if (typeof target === "object") { - throw new Error("not implemented"); - } + const socket = new Socket(); + socket.connect(target, host, callback); - return this.client.createConnection(target, typeof host === "function" ? host : callback) as net.Socket; - } - - public isIP(_input: string): number { - throw new Error("not implemented"); - } - - public isIPv4(_input: string): boolean { - throw new Error("not implemented"); - } - - public isIPv6(_input: string): boolean { - throw new Error("not implemented"); + return socket; } public createServer( - _options?: { allowHalfOpen?: boolean, pauseOnConnect?: boolean } | ((socket: net.Socket) => void), - _connectionListener?: (socket: net.Socket) => void, + options?: { allowHalfOpen?: boolean, pauseOnConnect?: boolean } | ((socket: net.Socket) => void), + connectionListener?: (socket: net.Socket) => void, ): net.Server { - return this.client.createServer() as net.Server; + return new Server(options, connectionListener); } + + public connect(): net.Socket { throw new Error("not implemented"); } + public isIP(_input: string): number { throw new Error("not implemented"); } + public isIPv4(_input: string): boolean { throw new Error("not implemented"); } + public isIPv6(_input: string): boolean { throw new Error("not implemented"); } } -export = new Net(client); +export = new Net(); diff --git a/packages/logger/src/logger.ts b/packages/logger/src/logger.ts index 9494b596a..cfd19a7b2 100644 --- a/packages/logger/src/logger.ts +++ b/packages/logger/src/logger.ts @@ -228,6 +228,7 @@ export class Logger { const envLevel = typeof global !== "undefined" && typeof global.process !== "undefined" ? global.process.env.LOG_LEVEL : process.env.LOG_LEVEL; if (envLevel) { switch (envLevel) { + case "trace": this.level = Level.Trace; break; case "debug": this.level = Level.Debug; break; case "info": this.level = Level.Info; break; case "warn": this.level = Level.Warning; break; @@ -277,6 +278,21 @@ export class Logger { }); } + /** + * Outputs a trace message. + */ + public trace(fn: LogCallback): void; + public trace(message: string, ...fields: FieldArray): void; + public trace(message: LogCallback | string, ...fields: FieldArray): void { + this.handle({ + type: "trace", + message, + fields, + tagColor: "#888888", + level: Level.Trace, + }); + } + /** * Outputs a debug message. */ @@ -324,7 +340,7 @@ export class Logger { * Outputs a message. */ private handle(options: { - type: "info" | "warn" | "debug" | "error"; + type: "trace" | "info" | "warn" | "debug" | "error"; message: string | LogCallback; fields?: FieldArray; level: Level; diff --git a/packages/protocol/src/browser/client.ts b/packages/protocol/src/browser/client.ts index abbc5925a..941183845 100644 --- a/packages/protocol/src/browser/client.ts +++ b/packages/protocol/src/browser/client.ts @@ -1,31 +1,20 @@ -import { ReadWriteConnection, InitData, OperatingSystem, SharedProcessData } from "../common/connection"; -import { NewEvalMessage, ServerMessage, EvalDoneMessage, EvalFailedMessage, TypedValue, ClientMessage, NewSessionMessage, TTYDimensions, SessionOutputMessage, CloseSessionInputMessage, WorkingInitMessage, EvalEventMessage } from "../proto"; +import { EventEmitter } from "events"; import { Emitter } from "@coder/events"; import { logger, field } from "@coder/logger"; -import { ChildProcess, SpawnOptions, ForkOptions, ServerProcess, ServerSocket, Socket, ServerListener, Server, ActiveEval } from "./command"; -import { EventEmitter } from "events"; -import { Socket as NetSocket } from "net"; +import { ReadWriteConnection, InitData, OperatingSystem, SharedProcessData } from "../common/connection"; +import { Disposer, stringify, parse } from "../common/util"; +import { NewEvalMessage, ServerMessage, EvalDoneMessage, EvalFailedMessage, ClientMessage, WorkingInitMessage, EvalEventMessage } from "../proto"; +import { ActiveEval } from "./command"; /** * Client accepts an arbitrary connection intended to communicate with the Server. */ export class Client { - public readonly Socket: typeof NetSocket; - private evalId = 0; private readonly evalDoneEmitter = new Emitter(); private readonly evalFailedEmitter = new Emitter(); private readonly evalEventEmitter = new Emitter(); - private sessionId = 0; - private readonly sessions = new Map(); - - private connectionId = 0; - private readonly connections = new Map(); - - private serverId = 0; - private readonly servers = new Map(); - private _initData: InitData | undefined; private readonly initDataEmitter = new Emitter(); private readonly initDataPromise: Promise; @@ -40,21 +29,20 @@ export class Client { private readonly connection: ReadWriteConnection, ) { connection.onMessage((data) => { + let message: ServerMessage | undefined; try { - this.handleMessage(ServerMessage.deserializeBinary(data)); - } catch (ex) { - logger.error("Failed to handle server message", field("length", data.byteLength), field("exception", ex)); + message = ServerMessage.deserializeBinary(data); + this.handleMessage(message); + } catch (error) { + logger.error( + "Failed to handle server message", + field("id", message && message.hasEvalEvent() ? message.getEvalEvent()!.getId() : undefined), + field("length", data.byteLength), + field("error", error.message), + ); } }); - const that = this; - // @ts-ignore NOTE: this doesn't fully implement net.Socket. - this.Socket = class extends ServerSocket { - public constructor() { - super(that.connection, that.connectionId++, that.registerConnection); - } - }; - this.initDataPromise = new Promise((resolve): void => { this.initDataEmitter.event(resolve); }); @@ -64,44 +52,55 @@ export class Client { return this.initDataPromise; } - public run(func: (ae: ActiveEval) => void | Promise): ActiveEval; - public run(func: (ae: ActiveEval, a1: T1) => void | Promise, a1: T1): ActiveEval; - public run(func: (ae: ActiveEval, a1: T1, a2: T2) => void | Promise, a1: T1, a2: T2): ActiveEval; - public run(func: (ae: ActiveEval, a1: T1, a2: T2, a3: T3) => void | Promise, a1: T1, a2: T2, a3: T3): ActiveEval; - public run(func: (ae: ActiveEval, a1: T1, a2: T2, a3: T3, a4: T4) => void | Promise, a1: T1, a2: T2, a3: T3, a4: T4): ActiveEval; - public run(func: (ae: ActiveEval, a1: T1, a2: T2, a3: T3, a4: T4, a5: T5) => void | Promise, a1: T1, a2: T2, a3: T3, a4: T4, a5: T5): ActiveEval; - public run(func: (ae: ActiveEval, a1: T1, a2: T2, a3: T3, a4: T4, a5: T5, a6: T6) => void | Promise, a1: T1, a2: T2, a3: T3, a4: T4, a5: T5, a6: T6): ActiveEval; - - public run(func: (ae: ActiveEval, a1?: T1, a2?: T2, a3?: T3, a4?: T4, a5?: T5, a6?: T6) => void | Promise, a1?: T1, a2?: T2, a3?: T3, a4?: T4, a5?: T5, a6?: T6): ActiveEval { + public run(func: (ae: ActiveEval) => Disposer): ActiveEval; + public run(func: (ae: ActiveEval, a1: T1) => Disposer, a1: T1): ActiveEval; + public run(func: (ae: ActiveEval, a1: T1, a2: T2) => Disposer, a1: T1, a2: T2): ActiveEval; + public run(func: (ae: ActiveEval, a1: T1, a2: T2, a3: T3) => Disposer, a1: T1, a2: T2, a3: T3): ActiveEval; + public run(func: (ae: ActiveEval, a1: T1, a2: T2, a3: T3, a4: T4) => Disposer, a1: T1, a2: T2, a3: T3, a4: T4): ActiveEval; + public run(func: (ae: ActiveEval, a1: T1, a2: T2, a3: T3, a4: T4, a5: T5) => Disposer, a1: T1, a2: T2, a3: T3, a4: T4, a5: T5): ActiveEval; + public run(func: (ae: ActiveEval, a1: T1, a2: T2, a3: T3, a4: T4, a5: T5, a6: T6) => Disposer, a1: T1, a2: T2, a3: T3, a4: T4, a5: T5, a6: T6): ActiveEval; + /** + * Run a function on the server and provide an event emitter which allows + * listening and emitting to the emitter provided to that function. The + * function should return a disposer for cleaning up when the client + * disconnects and for notifying when disposal has happened outside manual + * activation. + */ + public run(func: (ae: ActiveEval, a1?: T1, a2?: T2, a3?: T3, a4?: T4, a5?: T5, a6?: T6) => Disposer, a1?: T1, a2?: T2, a3?: T3, a4?: T4, a5?: T5, a6?: T6): ActiveEval { const doEval = this.doEvaluate(func, a1, a2, a3, a4, a5, a6, true); + + // This takes server events and emits them to the client's emitter. const eventEmitter = new EventEmitter(); const d1 = this.evalEventEmitter.event((msg) => { - if (msg.getId() !== doEval.id) { - return; + if (msg.getId() === doEval.id) { + eventEmitter.emit(msg.getEvent(), ...msg.getArgsList().map(parse)); } - - eventEmitter.emit(msg.getEvent(), ...msg.getArgsList().filter(a => a).map(s => JSON.parse(s))); }); doEval.completed.then(() => { d1.dispose(); - eventEmitter.emit("close"); }).catch((ex) => { d1.dispose(); + // This error event is only received by the client. eventEmitter.emit("error", ex); }); + // This takes client events and emits them to the server's emitter and + // listens to events received from the server (via the event hook above). return { + // tslint:disable no-any on: (event: string, cb: (...args: any[]) => void): EventEmitter => eventEmitter.on(event, cb), emit: (event: string, ...args: any[]): void => { const eventsMsg = new EvalEventMessage(); eventsMsg.setId(doEval.id); eventsMsg.setEvent(event); - eventsMsg.setArgsList(args.filter(a => a).map(a => JSON.stringify(a))); + eventsMsg.setArgsList(args.map(stringify)); const clientMsg = new ClientMessage(); clientMsg.setEvalEvent(eventsMsg); this.connection.send(clientMsg.serializeBinary()); }, + removeAllListeners: (event: string): EventEmitter => eventEmitter.removeAllListeners(event), + // tslint:enable no-any }; } @@ -128,6 +127,7 @@ export class Client { return this.doEvaluate(func, a1, a2, a3, a4, a5, a6, false).completed; } + // tslint:disable-next-line no-any private doEvaluate(func: (...args: any[]) => void | Promise | R | Promise, a1?: T1, a2?: T2, a3?: T3, a4?: T4, a5?: T5, a6?: T6, active: boolean = false): { readonly completed: Promise; readonly id: number; @@ -136,163 +136,36 @@ export class Client { const id = this.evalId++; newEval.setId(id); newEval.setActive(active); - newEval.setArgsList([a1, a2, a3, a4, a5, a6].filter(a => typeof a !== "undefined").map(a => JSON.stringify(a))); + newEval.setArgsList([a1, a2, a3, a4, a5, a6].map(stringify)); newEval.setFunction(func.toString()); const clientMsg = new ClientMessage(); clientMsg.setNewEval(newEval); this.connection.send(clientMsg.serializeBinary()); - let res: (value?: R) => void; - let rej: (err?: Error) => void; - const prom = new Promise((r, e): void => { - res = r; - rej = e; - }); - - const d1 = this.evalDoneEmitter.event((doneMsg) => { - if (doneMsg.getId() !== id) { - return; - } - - d1.dispose(); - d2.dispose(); - - const resp = doneMsg.getResponse(); - if (!resp) { - return res(); - } - - const rt = resp.getType(); - // tslint:disable-next-line no-any - let val: any; - switch (rt) { - case TypedValue.Type.BOOLEAN: - val = resp.getValue() === "true"; - break; - case TypedValue.Type.NUMBER: - val = parseInt(resp.getValue(), 10); - break; - case TypedValue.Type.OBJECT: - val = JSON.parse(resp.getValue()); - break; - case TypedValue.Type.STRING: - val = resp.getValue(); - break; - default: - throw new Error(`unsupported typed value ${rt}`); - } - - res(val); - }); - - const d2 = this.evalFailedEmitter.event((failedMsg) => { - if (failedMsg.getId() === id) { + const completed = new Promise((resolve, reject): void => { + const dispose = (): void => { d1.dispose(); d2.dispose(); + }; - rej(new Error(failedMsg.getMessage())); - } + const d1 = this.evalDoneEmitter.event((doneMsg) => { + if (doneMsg.getId() === id) { + const resp = doneMsg.getResponse(); + dispose(); + resolve(parse(resp)); + } + }); + + const d2 = this.evalFailedEmitter.event((failedMsg) => { + if (failedMsg.getId() === id) { + dispose(); + reject(new Error(failedMsg.getMessage())); + } + }); }); - return { - completed: prom, - id, - }; - } - - /** - * Spawns a process from a command. _Somewhat_ reflects the "child_process" API. - * @example - * const cp = this.client.spawn("echo", ["test"]); - * cp.stdout.on("data", (data) => console.log(data.toString())); - * cp.on("exit", (code) => console.log("exited with", code)); - * @param args Arguments - * @param options Options to execute for the command - */ - public spawn(command: string, args: string[] = [], options?: SpawnOptions): ChildProcess { - return this.doSpawn(command, args, options, false, false); - } - - /** - * Fork a module. - * @param modulePath Path of the module - * @param args Args to add for the module - * @param options Options to execute - */ - public fork(modulePath: string, args: string[] = [], options?: ForkOptions): ChildProcess { - return this.doSpawn(modulePath, args, options, true); - } - - /** - * VS Code specific. - * Forks a module from bootstrap-fork - * @param modulePath Path of the module - */ - public bootstrapFork(modulePath: string, args: string[] = [], options?: ForkOptions): ChildProcess { - return this.doSpawn(modulePath, args, options, true, true); - } - - public createConnection(path: string, callback?: Function): Socket; - public createConnection(port: number, callback?: Function): Socket; - public createConnection(target: string | number, callback?: Function): Socket; - public createConnection(target: string | number, callback?: Function): Socket { - const id = this.connectionId++; - const socket = new ServerSocket(this.connection, id, this.registerConnection); - socket.connect(target, callback); - - return socket; - } - - public createServer(callback?: () => void): Server { - const id = this.serverId++; - const server = new ServerListener(this.connection, id, callback); - this.servers.set(id, server); - - return server; - } - - private doSpawn(command: string, args: string[] = [], options?: SpawnOptions, isFork: boolean = false, isBootstrapFork: boolean = true): ChildProcess { - const id = this.sessionId++; - const newSess = new NewSessionMessage(); - newSess.setId(id); - newSess.setCommand(command); - newSess.setArgsList(args); - newSess.setIsFork(isFork); - newSess.setIsBootstrapFork(isBootstrapFork); - if (options) { - if (options.cwd) { - newSess.setCwd(options.cwd); - } - if (options.env) { - Object.keys(options.env).forEach((envKey) => { - if (options.env![envKey]) { - newSess.getEnvMap().set(envKey, options.env![envKey].toString()); - } - }); - } - if (options.tty) { - const tty = new TTYDimensions(); - tty.setHeight(options.tty.rows); - tty.setWidth(options.tty.columns); - newSess.setTtyDimensions(tty); - } - } - const clientMsg = new ClientMessage(); - clientMsg.setNewSession(newSess); - this.connection.send(clientMsg.serializeBinary()); - - const serverProc = new ServerProcess(this.connection, id, options ? options.tty !== undefined : false, isBootstrapFork); - serverProc.stdin.on("close", () => { - const c = new CloseSessionInputMessage(); - c.setId(id); - const cm = new ClientMessage(); - cm.setCloseSessionInput(c); - this.connection.send(cm.serializeBinary()); - }); - this.sessions.set(id, serverProc); - - return serverProc; + return { completed, id }; } /** @@ -332,121 +205,12 @@ export class Client { this.evalFailedEmitter.emit(message.getEvalFailed()!); } else if (message.hasEvalEvent()) { this.evalEventEmitter.emit(message.getEvalEvent()!); - } else if (message.hasNewSessionFailure()) { - const s = this.sessions.get(message.getNewSessionFailure()!.getId()); - if (!s) { - return; - } - s.emit("error", new Error(message.getNewSessionFailure()!.getMessage())); - this.sessions.delete(message.getNewSessionFailure()!.getId()); - } else if (message.hasSessionDone()) { - const s = this.sessions.get(message.getSessionDone()!.getId()); - if (!s) { - return; - } - s.emit("exit", message.getSessionDone()!.getExitStatus()); - this.sessions.delete(message.getSessionDone()!.getId()); - } else if (message.hasSessionOutput()) { - const output = message.getSessionOutput()!; - const s = this.sessions.get(output.getId()); - if (!s) { - return; - } - const data = new TextDecoder().decode(output.getData_asU8()); - const source = output.getSource(); - switch (source) { - case SessionOutputMessage.Source.STDOUT: - case SessionOutputMessage.Source.STDERR: - (source === SessionOutputMessage.Source.STDOUT ? s.stdout : s.stderr).emit("data", data); - break; - case SessionOutputMessage.Source.IPC: - s.emit("message", JSON.parse(data)); - break; - default: - throw new Error(`Unknown source ${source}`); - } - } else if (message.hasIdentifySession()) { - const s = this.sessions.get(message.getIdentifySession()!.getId()); - if (!s) { - return; - } - const pid = message.getIdentifySession()!.getPid(); - if (typeof pid !== "undefined") { - s.pid = pid; - } - const title = message.getIdentifySession()!.getTitle(); - if (typeof title !== "undefined") { - s.title = title; - } - } else if (message.hasConnectionEstablished()) { - const c = this.connections.get(message.getConnectionEstablished()!.getId()); - if (!c) { - return; - } - c.emit("connect"); - } else if (message.hasConnectionOutput()) { - const c = this.connections.get(message.getConnectionOutput()!.getId()); - if (!c) { - return; - } - c.emit("data", Buffer.from(message.getConnectionOutput()!.getData_asU8())); - } else if (message.hasConnectionClose()) { - const c = this.connections.get(message.getConnectionClose()!.getId()); - if (!c) { - return; - } - c.emit("close"); - c.emit("end"); - this.connections.delete(message.getConnectionClose()!.getId()); - } else if (message.hasConnectionFailure()) { - const c = this.connections.get(message.getConnectionFailure()!.getId()); - if (!c) { - return; - } - c.emit("end"); - this.connections.delete(message.getConnectionFailure()!.getId()); } else if (message.hasSharedProcessActive()) { + const sharedProcessActiveMessage = message.getSharedProcessActive()!; this.sharedProcessActiveEmitter.emit({ - socketPath: message.getSharedProcessActive()!.getSocketPath(), - logPath: message.getSharedProcessActive()!.getLogPath(), + socketPath: sharedProcessActiveMessage.getSocketPath(), + logPath: sharedProcessActiveMessage.getLogPath(), }); - } else if (message.hasServerEstablished()) { - const s = this.servers.get(message.getServerEstablished()!.getId()); - if (!s) { - return; - } - s.emit("connect"); - } else if (message.hasServerConnectionEstablished()) { - const s = this.servers.get(message.getServerConnectionEstablished()!.getServerId()); - if (!s) { - return; - } - const conId = message.getServerConnectionEstablished()!.getConnectionId(); - const serverSocket = new ServerSocket(this.connection, conId, this.registerConnection); - this.registerConnection(conId, serverSocket); - serverSocket.emit("connect"); - s.emit("connection", serverSocket); - } else if (message.getServerFailure()) { - const s = this.servers.get(message.getServerFailure()!.getId()); - if (!s) { - return; - } - s.emit("error", new Error(message.getNewSessionFailure()!.getReason().toString())); - this.servers.delete(message.getNewSessionFailure()!.getId()); - } else if (message.hasServerClose()) { - const s = this.servers.get(message.getServerClose()!.getId()); - if (!s) { - return; - } - s.emit("close"); - this.servers.delete(message.getServerClose()!.getId()); } } - - private registerConnection = (id: number, socket: ServerSocket): void => { - if (this.connections.has(id)) { - throw new Error(`${id} is already registered`); - } - this.connections.set(id, socket); - } } diff --git a/packages/protocol/src/browser/command.ts b/packages/protocol/src/browser/command.ts index 64060002c..780d20b86 100644 --- a/packages/protocol/src/browser/command.ts +++ b/packages/protocol/src/browser/command.ts @@ -1,366 +1,8 @@ -import * as events from "events"; -import * as stream from "stream"; -import { ReadWriteConnection } from "../common/connection"; -import { NewConnectionMessage, ShutdownSessionMessage, ClientMessage, WriteToSessionMessage, ResizeSessionTTYMessage, TTYDimensions as ProtoTTYDimensions, ConnectionOutputMessage, ConnectionCloseMessage, ServerCloseMessage, NewServerMessage } from "../proto"; - -export interface TTYDimensions { - readonly columns: number; - readonly rows: number; -} - -export interface SpawnOptions { - cwd?: string; - env?: { [key: string]: string }; - tty?: TTYDimensions; -} - -export interface ForkOptions { - cwd?: string; - env?: { [key: string]: string }; -} - -export interface ChildProcess { - readonly stdin: stream.Writable; - readonly stdout: stream.Readable; - readonly stderr: stream.Readable; - - readonly killed?: boolean; - readonly pid: number | undefined; - readonly title?: string; - - kill(signal?: string): void; - - send(message: string | Uint8Array, callback?: () => void, ipc?: false): void; - send(message: any, callback: undefined | (() => void), ipc: true): void; - - on(event: "message", listener: (data: any) => void): void; - on(event: "error", listener: (err: Error) => void): void; - on(event: "exit", listener: (code: number, signal: string) => void): void; - - resize?(dimensions: TTYDimensions): void; -} - -export class ServerProcess extends events.EventEmitter implements ChildProcess { - public readonly stdin = new stream.Writable(); - public readonly stdout = new stream.Readable({ read: (): boolean => true }); - public readonly stderr = new stream.Readable({ read: (): boolean => true }); - - private _pid: number | undefined; - private _title: string | undefined; - private _killed: boolean = false; - private _connected: boolean = false; - - public constructor( - private readonly connection: ReadWriteConnection, - private readonly id: number, - private readonly hasTty: boolean = false, - private readonly ipc: boolean = false, - ) { - super(); - if (!this.hasTty) { - delete this.resize; - } - } - - public get pid(): number | undefined { - return this._pid; - } - - public set pid(pid: number | undefined) { - this._pid = pid; - this._connected = true; - } - - public get title(): string | undefined { - return this._title; - } - - public set title(title: string | undefined) { - this._title = title; - } - - public get connected(): boolean { - return this._connected; - } - - public get killed(): boolean { - return this._killed; - } - - public kill(signal?: string): void { - const kill = new ShutdownSessionMessage(); - kill.setId(this.id); - if (signal) { - kill.setSignal(signal); - } - const client = new ClientMessage(); - client.setShutdownSession(kill); - this.connection.send(client.serializeBinary()); - - this._killed = true; - this._connected = false; - } - - public send(message: string | Uint8Array | any, callback?: (error: Error | null) => void, ipc: boolean = this.ipc): boolean { - const send = new WriteToSessionMessage(); - send.setId(this.id); - send.setSource(ipc ? WriteToSessionMessage.Source.IPC : WriteToSessionMessage.Source.STDIN); - if (ipc) { - send.setData(new TextEncoder().encode(JSON.stringify(message))); - } else { - send.setData(typeof message === "string" ? new TextEncoder().encode(message) : message); - } - const client = new ClientMessage(); - client.setWriteToSession(send); - this.connection.send(client.serializeBinary()); - // TODO: properly implement? - if (callback) { - callback(null); - } - - return true; - } - - public resize(dimensions: TTYDimensions): void { - const resize = new ResizeSessionTTYMessage(); - resize.setId(this.id); - const tty = new ProtoTTYDimensions(); - tty.setHeight(dimensions.rows); - tty.setWidth(dimensions.columns); - resize.setTtyDimensions(tty); - const client = new ClientMessage(); - client.setResizeSessionTty(resize); - this.connection.send(client.serializeBinary()); - } -} - -export interface Socket { - readonly destroyed: boolean; - readonly connecting: boolean; - write(buffer: Buffer): void; - end(): void; - - connect(path: string, callback?: () => void): void; - connect(port: number, callback?: () => void): void; - - addListener(event: "data", listener: (data: Buffer) => void): this; - addListener(event: "close", listener: (hasError: boolean) => void): this; - addListener(event: "connect", listener: () => void): this; - addListener(event: "end", listener: () => void): this; - - on(event: "data", listener: (data: Buffer) => void): this; - on(event: "close", listener: (hasError: boolean) => void): this; - on(event: "connect", listener: () => void): this; - on(event: "end", listener: () => void): this; - - once(event: "data", listener: (data: Buffer) => void): this; - once(event: "close", listener: (hasError: boolean) => void): this; - once(event: "connect", listener: () => void): this; - once(event: "end", listener: () => void): this; - - removeListener(event: "data", listener: (data: Buffer) => void): this; - removeListener(event: "close", listener: (hasError: boolean) => void): this; - removeListener(event: "connect", listener: () => void): this; - removeListener(event: "end", listener: () => void): this; - - emit(event: "data", data: Buffer): boolean; - emit(event: "close"): boolean; - emit(event: "connect"): boolean; - emit(event: "end"): boolean; -} - -export class ServerSocket extends events.EventEmitter implements Socket { - public writable: boolean = true; - public readable: boolean = true; - - private _destroyed: boolean = false; - private _connecting: boolean = false; - - public constructor( - private readonly connection: ReadWriteConnection, - private readonly id: number, - private readonly beforeConnect: (id: number, socket: ServerSocket) => void, - ) { - super(); - } - - public connect(target: string | number, callback?: Function): void { - this._connecting = true; - this.beforeConnect(this.id, this); - - this.once("connect", () => { - this._connecting = false; - if (callback) { - callback(); - } - }); - - const newCon = new NewConnectionMessage(); - newCon.setId(this.id); - if (typeof target === "string") { - newCon.setPath(target); - } else { - newCon.setPort(target); - } - const clientMsg = new ClientMessage(); - clientMsg.setNewConnection(newCon); - this.connection.send(clientMsg.serializeBinary()); - } - - public get destroyed(): boolean { - return this._destroyed; - } - - public get connecting(): boolean { - return this._connecting; - } - - public write(buffer: Buffer): void { - const sendData = new ConnectionOutputMessage(); - sendData.setId(this.id); - sendData.setData(buffer); - const client = new ClientMessage(); - client.setConnectionOutput(sendData); - this.connection.send(client.serializeBinary()); - } - - public end(): void { - const closeMsg = new ConnectionCloseMessage(); - closeMsg.setId(this.id); - const client = new ClientMessage(); - client.setConnectionClose(closeMsg); - this.connection.send(client.serializeBinary()); - } - - public addListener(event: "data", listener: (data: Buffer) => void): this; - public addListener(event: "close", listener: (hasError: boolean) => void): this; - public addListener(event: "connect", listener: () => void): this; - public addListener(event: "end", listener: () => void): this; - public addListener(event: string, listener: any): this { - return super.addListener(event, listener); - } - - public removeListener(event: "data", listener: (data: Buffer) => void): this; - public removeListener(event: "close", listener: (hasError: boolean) => void): this; - public removeListener(event: "connect", listener: () => void): this; - public removeListener(event: "end", listener: () => void): this; - public removeListener(event: string, listener: any): this { - return super.removeListener(event, listener); - } - - public on(event: "data", listener: (data: Buffer) => void): this; - public on(event: "close", listener: (hasError: boolean) => void): this; - public on(event: "connect", listener: () => void): this; - public on(event: "end", listener: () => void): this; - public on(event: string, listener: any): this { - return super.on(event, listener); - } - - public once(event: "data", listener: (data: Buffer) => void): this; - public once(event: "close", listener: (hasError: boolean) => void): this; - public once(event: "connect", listener: () => void): this; - public once(event: "end", listener: () => void): this; - public once(event: string, listener: any): this { - return super.once(event, listener); - } - - public emit(event: "data", data: Buffer): boolean; - public emit(event: "close"): boolean; - public emit(event: "connect"): boolean; - public emit(event: "end"): boolean; - public emit(event: string, ...args: any[]): boolean { - return super.emit(event, ...args); - } - - public setDefaultEncoding(encoding: string): this { - throw new Error("Method not implemented."); - } -} - -export interface Server { - addListener(event: "close", listener: () => void): this; - addListener(event: "connect", listener: (socket: Socket) => void): this; - addListener(event: "error", listener: (err: Error) => void): this; - - on(event: "close", listener: () => void): this; - on(event: "connection", listener: (socket: Socket) => void): this; - on(event: "error", listener: (err: Error) => void): this; - - once(event: "close", listener: () => void): this; - once(event: "connection", listener: (socket: Socket) => void): this; - once(event: "error", listener: (err: Error) => void): this; - - removeListener(event: "close", listener: () => void): this; - removeListener(event: "connection", listener: (socket: Socket) => void): this; - removeListener(event: "error", listener: (err: Error) => void): this; - - emit(event: "close"): boolean; - emit(event: "connection"): boolean; - emit(event: "error"): boolean; - - listen(path: string, listeningListener?: () => void): this; - close(callback?: () => void): this; - - readonly listening: boolean; -} - -export class ServerListener extends events.EventEmitter implements Server { - private _listening: boolean = false; - - public constructor( - private readonly connection: ReadWriteConnection, - private readonly id: number, - connectCallback?: () => void, - ) { - super(); - - this.on("connect", () => { - this._listening = true; - if (connectCallback) { - connectCallback(); - } - }); - } - - public get listening(): boolean { - return this._listening; - } - - public listen(path: string, listener?: () => void): this { - const ns = new NewServerMessage(); - ns.setId(this.id); - ns.setPath(path!); - const cm = new ClientMessage(); - cm.setNewServer(ns); - this.connection.send(cm.serializeBinary()); - - if (typeof listener !== "undefined") { - this.once("connect", listener); - } - - return this; - } - - public close(callback?: Function | undefined): this { - const closeMsg = new ServerCloseMessage(); - closeMsg.setId(this.id); - closeMsg.setReason("Manually closed"); - const clientMsg = new ClientMessage(); - clientMsg.setServerClose(closeMsg); - this.connection.send(clientMsg.serializeBinary()); - - if (callback) { - callback(); - } - - return this; - } -} - export interface ActiveEval { - emit(event: string, ...args: any[]): void; + removeAllListeners(event?: string): void; - on(event: "close", cb: () => void): void; - on(event: "error", cb: (err: Error) => void): void; + // tslint:disable no-any + emit(event: string, ...args: any[]): void; on(event: string, cb: (...args: any[]) => void): void; + // tslint:disable no-any } diff --git a/packages/protocol/src/common/util.ts b/packages/protocol/src/common/util.ts index 25f8018a3..4c995e42a 100644 --- a/packages/protocol/src/common/util.ts +++ b/packages/protocol/src/common/util.ts @@ -1,3 +1,5 @@ +import { IDisposable } from "@coder/disposable"; + /** * Return true if we're in a browser environment (including web workers). */ @@ -25,10 +27,54 @@ export type IEncodingOptions = { export type IEncodingOptionsCallback = IEncodingOptions | ((err: NodeJS.ErrnoException, ...args: any[]) => void); /** - * Return true if the options specify to use a Buffer instead of string. + * Stringify an event argument. */ -export const useBuffer = (options: IEncodingOptionsCallback): boolean => { - return options === "buffer" - || (!!options && typeof options !== "string" && typeof options !== "function" - && (options.encoding === "buffer" || options.encoding === null)); +export const stringify = (arg: any): string => { // tslint:disable-line no-any + if (arg instanceof Error) { + return JSON.stringify({ + type: "Error", + data: { + message: arg.message, + name: arg.name, + stack: arg.stack, + }, + }); + } + + return JSON.stringify(arg); }; +/** + * Parse an event argument. + */ +export const parse = (arg: string): any => { // tslint:disable-line no-any + if (!arg) { + return arg; + } + + const result = JSON.parse(arg); + + if (result && result.data && result.type) { + switch (result.type) { + // JSON.stringify turns a Buffer into an object but JSON.parse doesn't + // turn it back, it just remains an object. + case "Buffer": + if (Array.isArray(result.data)) { + return Buffer.from(result); + } + break; + // Errors apparently can't be stringified, so we do something similar to + // what happens to buffers and stringify them as regular objects. + case "Error": + if (result.data.message) { + return new Error(result.data.message); + } + break; + } + } + + return result; +}; + +export interface Disposer extends IDisposable { + onDidDispose: (cb: () => void) => void; +} diff --git a/packages/protocol/src/index.ts b/packages/protocol/src/index.ts index 28d6edd65..f0b57711d 100644 --- a/packages/protocol/src/index.ts +++ b/packages/protocol/src/index.ts @@ -1,3 +1,4 @@ export * from "./browser/client"; +export { ActiveEval } from "./browser/command"; export * from "./common/connection"; export * from "./common/util"; diff --git a/packages/protocol/src/node/command.ts b/packages/protocol/src/node/command.ts deleted file mode 100644 index 0738f102e..000000000 --- a/packages/protocol/src/node/command.ts +++ /dev/null @@ -1,349 +0,0 @@ -import * as cp from "child_process"; -import * as net from "net"; -import * as stream from "stream"; -import { TextEncoder } from "text-encoding"; -import { Logger, logger, field } from "@coder/logger"; -import { NewSessionMessage, ServerMessage, SessionDoneMessage, SessionOutputMessage, IdentifySessionMessage, NewConnectionMessage, ConnectionEstablishedMessage, NewConnectionFailureMessage, ConnectionCloseMessage, ConnectionOutputMessage, NewServerMessage, ServerEstablishedMessage, NewServerFailureMessage, ServerCloseMessage, ServerConnectionEstablishedMessage } from "../proto"; -import { SendableConnection } from "../common/connection"; -import { ServerOptions } from "./server"; - -export interface Process { - stdio?: Array; - stdin?: stream.Writable; - stdout?: stream.Readable; - stderr?: stream.Readable; - send?: (message: string) => void; - - pid: number; - killed?: boolean; - - on(event: "data" | "message", cb: (data: string) => void): void; - on(event: "exit", listener: (exitCode: number, signal?: number) => void): void; - write(data: string | Uint8Array): void; - resize?(cols: number, rows: number): void; - kill(signal?: string): void; - title?: number; -} - -export const handleNewSession = (connection: SendableConnection, newSession: NewSessionMessage, serverOptions: ServerOptions | undefined, onExit: () => void): Process => { - const childLogger = getChildLogger(newSession.getCommand()); - childLogger.debug(() => [ - newSession.getIsFork() ? "Forking" : "Spawning", - field("command", newSession.getCommand()), - field("args", newSession.getArgsList()), - field("env", newSession.getEnvMap().toObject()), - ]); - - let process: Process; - let processTitle: string | undefined; - - const env: { [key: string]: string } = {}; - newSession.getEnvMap().forEach((value, key) => { - env[key] = value; - }); - if (newSession.getTtyDimensions()) { - // Spawn with node-pty - const nodePty = require("node-pty") as typeof import("node-pty"); - const ptyProc = nodePty.spawn(newSession.getCommand(), newSession.getArgsList(), { - cols: newSession.getTtyDimensions()!.getWidth(), - rows: newSession.getTtyDimensions()!.getHeight(), - cwd: newSession.getCwd(), - env, - }); - - const timer = setInterval(() => { - if (ptyProc.process !== processTitle) { - processTitle = ptyProc.process; - const id = new IdentifySessionMessage(); - id.setId(newSession.getId()); - id.setTitle(processTitle!); - const sm = new ServerMessage(); - sm.setIdentifySession(id); - connection.send(sm.serializeBinary()); - } - }, 200); - - ptyProc.on("exit", () => { - clearTimeout(timer); - }); - - process = ptyProc; - processTitle = ptyProc.process; - } else { - const options = { - cwd: newSession.getCwd(), - env, - }; - let proc: cp.ChildProcess; - if (newSession.getIsFork()) { - if (!serverOptions) { - throw new Error("No forkProvider set for bootstrap-fork request"); - } - - if (!serverOptions.forkProvider) { - throw new Error("No forkProvider set for server options"); - } - - proc = serverOptions.forkProvider(newSession); - } else { - proc = cp.spawn(newSession.getCommand(), newSession.getArgsList(), options); - } - - process = { - stdin: proc.stdin, - stderr: proc.stderr, - stdout: proc.stdout, - stdio: proc.stdio, - send: (message): void => { - proc.send(message); - }, - on: (...args: any[]): void => ((proc as any).on)(...args), // tslint:disable-line no-any - write: (d): boolean => proc.stdin.write(d), - kill: (s): void => proc.kill(s || "SIGTERM"), - pid: proc.pid, - }; - } - - const sendOutput = (_source: SessionOutputMessage.Source, msg: string | Uint8Array): void => { - childLogger.debug(() => { - - let data = msg.toString(); - if (_source === SessionOutputMessage.Source.IPC) { - // data = Buffer.from(msg.toString(), "base64").toString(); - } - - return [ - _source === SessionOutputMessage.Source.STDOUT - ? "stdout" - : (_source === SessionOutputMessage.Source.STDERR ? "stderr" : "ipc"), - field("id", newSession.getId()), - field("data", data), - ]; - }); - const serverMsg = new ServerMessage(); - const d = new SessionOutputMessage(); - d.setId(newSession.getId()); - d.setData(typeof msg === "string" ? new TextEncoder().encode(msg) : msg); - d.setSource(_source); - serverMsg.setSessionOutput(d); - connection.send(serverMsg.serializeBinary()); - }; - - if (process.stdout && process.stderr) { - process.stdout.on("data", (data) => { - sendOutput(SessionOutputMessage.Source.STDOUT, data); - }); - - process.stderr.on("data", (data) => { - sendOutput(SessionOutputMessage.Source.STDERR, data); - }); - } else { - process.on("data", (data) => { - sendOutput(SessionOutputMessage.Source.STDOUT, Buffer.from(data)); - }); - } - - // IPC. - if (process.send) { - process.on("message", (data) => { - sendOutput(SessionOutputMessage.Source.IPC, JSON.stringify(data)); - }); - } - - const id = new IdentifySessionMessage(); - id.setId(newSession.getId()); - id.setPid(process.pid); - if (processTitle) { - id.setTitle(processTitle); - } - const sm = new ServerMessage(); - sm.setIdentifySession(id); - connection.send(sm.serializeBinary()); - - process.on("exit", (code) => { - childLogger.debug(() => [ - "Exited", - field("id", newSession.getId()), - field("command", newSession.getCommand()), - field("args", newSession.getArgsList()), - ]); - const serverMsg = new ServerMessage(); - const exit = new SessionDoneMessage(); - exit.setId(newSession.getId()); - exit.setExitStatus(code); - serverMsg.setSessionDone(exit); - connection.send(serverMsg.serializeBinary()); - - onExit(); - }); - - return process; -}; - -export const handleNewConnection = (connection: SendableConnection, newConnection: NewConnectionMessage, onExit: () => void): net.Socket => { - const target = newConnection.getPath() || `${newConnection.getPort()}`; - const childLogger = getChildLogger(target, ">"); - - const id = newConnection.getId(); - let socket: net.Socket; - let didConnect = false; - const connectCallback = (): void => { - childLogger.debug("Connected", field("id", newConnection.getId()), field("target", target)); - didConnect = true; - const estab = new ConnectionEstablishedMessage(); - estab.setId(id); - const servMsg = new ServerMessage(); - servMsg.setConnectionEstablished(estab); - connection.send(servMsg.serializeBinary()); - }; - - if (newConnection.getPath()) { - socket = net.createConnection(newConnection.getPath(), connectCallback); - } else if (newConnection.getPort()) { - socket = net.createConnection(newConnection.getPort(), undefined, connectCallback); - } else { - throw new Error("No path or port provided for new connection"); - } - - socket.addListener("error", (err) => { - childLogger.debug("Error", field("id", newConnection.getId()), field("error", err)); - if (!didConnect) { - const errMsg = new NewConnectionFailureMessage(); - errMsg.setId(id); - errMsg.setMessage(err.message); - const servMsg = new ServerMessage(); - servMsg.setConnectionFailure(errMsg); - connection.send(servMsg.serializeBinary()); - - onExit(); - } - }); - - socket.addListener("close", () => { - childLogger.debug("Closed", field("id", newConnection.getId())); - if (didConnect) { - const closed = new ConnectionCloseMessage(); - closed.setId(id); - const servMsg = new ServerMessage(); - servMsg.setConnectionClose(closed); - connection.send(servMsg.serializeBinary()); - - onExit(); - } - }); - - socket.addListener("data", (data) => { - childLogger.debug(() => [ - "ipc", - field("id", newConnection.getId()), - field("data", data), - ]); - const dataMsg = new ConnectionOutputMessage(); - dataMsg.setId(id); - dataMsg.setData(data); - const servMsg = new ServerMessage(); - servMsg.setConnectionOutput(dataMsg); - connection.send(servMsg.serializeBinary()); - }); - - return socket; -}; - -export const handleNewServer = (connection: SendableConnection, newServer: NewServerMessage, addSocket: (socket: net.Socket) => number, onExit: () => void, onSocketExit: (id: number) => void): net.Server => { - const target = newServer.getPath() || `${newServer.getPort()}`; - const childLogger = getChildLogger(target, "|"); - - const s = net.createServer(); - - try { - s.listen(newServer.getPath() ? newServer.getPath() : newServer.getPort(), () => { - childLogger.debug("Listening", field("id", newServer.getId()), field("target", target)); - const se = new ServerEstablishedMessage(); - se.setId(newServer.getId()); - const sm = new ServerMessage(); - sm.setServerEstablished(se); - connection.send(sm.serializeBinary()); - }); - } catch (ex) { - childLogger.debug("Failed to listen", field("id", newServer.getId()), field("target", target)); - const sf = new NewServerFailureMessage(); - sf.setId(newServer.getId()); - const sm = new ServerMessage(); - sm.setServerFailure(sf); - connection.send(sm.serializeBinary()); - - onExit(); - } - - s.on("close", () => { - childLogger.debug("Stopped listening", field("id", newServer.getId()), field("target", target)); - const sc = new ServerCloseMessage(); - sc.setId(newServer.getId()); - const sm = new ServerMessage(); - sm.setServerClose(sc); - connection.send(sm.serializeBinary()); - - onExit(); - }); - - s.on("connection", (socket) => { - const socketId = addSocket(socket); - childLogger.debug("Got connection", field("id", newServer.getId()), field("socketId", socketId)); - - const sock = new ServerConnectionEstablishedMessage(); - sock.setServerId(newServer.getId()); - sock.setConnectionId(socketId); - const sm = new ServerMessage(); - sm.setServerConnectionEstablished(sock); - connection.send(sm.serializeBinary()); - - socket.addListener("data", (data) => { - childLogger.debug(() => [ - "ipc", - field("id", newServer.getId()), - field("socketId", socketId), - field("data", data), - ]); - const dataMsg = new ConnectionOutputMessage(); - dataMsg.setId(socketId); - dataMsg.setData(data); - const servMsg = new ServerMessage(); - servMsg.setConnectionOutput(dataMsg); - connection.send(servMsg.serializeBinary()); - }); - - socket.on("error", (error) => { - childLogger.debug("Error", field("id", newServer.getId()), field("socketId", socketId), field("error", error)); - onSocketExit(socketId); - }); - - socket.on("close", () => { - childLogger.debug("Closed", field("id", newServer.getId()), field("socketId", socketId)); - onSocketExit(socketId); - }); - }); - - return s; -}; - -const getChildLogger = (command: string, prefix: string = ""): Logger => { - // TODO: Temporary, for debugging. Should probably ask for a name? - let name: string; - if (command.includes("vscode-ipc") || command.includes("extensionHost")) { - name = "exthost"; - } else if (command.includes("vscode-remote")) { - name = "shared"; - } else { - const basename = command.split("/").pop()!; - let i = 0; - for (; i < basename.length; i++) { - const character = basename.charAt(i); - if (isNaN(+character) && character === character.toUpperCase()) { - break; - } - } - name = basename.substring(0, i); - } - - return logger.named(prefix + name); -}; diff --git a/packages/protocol/src/node/evaluate.ts b/packages/protocol/src/node/evaluate.ts index d3373cfac..31067ae59 100644 --- a/packages/protocol/src/node/evaluate.ts +++ b/packages/protocol/src/node/evaluate.ts @@ -1,10 +1,13 @@ -import * as vm from "vm"; -import { NewEvalMessage, TypedValue, EvalFailedMessage, EvalDoneMessage, ServerMessage, EvalEventMessage } from "../proto"; -import { SendableConnection } from "../common/connection"; import { EventEmitter } from "events"; +import * as vm from "vm"; +import { logger, field } from "@coder/logger"; +import { NewEvalMessage, EvalFailedMessage, EvalDoneMessage, ServerMessage, EvalEventMessage } from "../proto"; +import { SendableConnection } from "../common/connection"; +import { stringify, parse } from "../common/util"; export interface ActiveEvaluation { onEvent(msg: EvalEventMessage): void; + dispose(): void; } declare var __non_webpack_require__: typeof require; @@ -13,96 +16,117 @@ export const evaluate = (connection: SendableConnection, message: NewEvalMessage message.getArgsList().forEach((value) => { argStr.push(value); }); + + /** + * Send the response and call onDispose. + */ + // tslint:disable-next-line no-any const sendResp = (resp: any): void => { const evalDone = new EvalDoneMessage(); evalDone.setId(message.getId()); - const tof = typeof resp; - if (tof !== "undefined") { - const tv = new TypedValue(); - let t: TypedValue.Type; - switch (tof) { - case "string": - t = TypedValue.Type.STRING; - break; - case "boolean": - t = TypedValue.Type.BOOLEAN; - break; - case "object": - t = TypedValue.Type.OBJECT; - break; - case "number": - t = TypedValue.Type.NUMBER; - break; - default: - return sendErr(EvalFailedMessage.Reason.EXCEPTION, `unsupported response type ${tof}`); - } - tv.setValue(tof === "string" ? resp : JSON.stringify(resp)); - tv.setType(t); - evalDone.setResponse(tv); - } + evalDone.setResponse(stringify(resp)); const serverMsg = new ServerMessage(); serverMsg.setEvalDone(evalDone); connection.send(serverMsg.serializeBinary()); + + onDispose(); }; - const sendErr = (reason: EvalFailedMessage.Reason, msg: string): void => { + + /** + * Send an exception and call onDispose. + */ + const sendException = (error: Error): void => { const evalFailed = new EvalFailedMessage(); evalFailed.setId(message.getId()); - evalFailed.setReason(reason); - evalFailed.setMessage(msg); + evalFailed.setReason(EvalFailedMessage.Reason.EXCEPTION); + evalFailed.setMessage(error.toString() + " " + error.stack); const serverMsg = new ServerMessage(); serverMsg.setEvalFailed(evalFailed); connection.send(serverMsg.serializeBinary()); - }; - let eventEmitter: EventEmitter | undefined; - try { - if (message.getActive()) { - eventEmitter = new EventEmitter(); - } - const value = vm.runInNewContext(`(${message.getFunction()})(${eventEmitter ? `eventEmitter, ` : ""}${argStr.join(",")})`, { - eventEmitter: eventEmitter ? { - on: (event: string, cb: (...args: any[]) => void): void => { - eventEmitter!.on(event, cb); - }, - emit: (event: string, ...args: any[]): void => { - const eventMsg = new EvalEventMessage(); - eventMsg.setEvent(event); - eventMsg.setArgsList(args.filter(a => a).map(a => JSON.stringify(a))); - eventMsg.setId(message.getId()); - const serverMsg = new ServerMessage(); - serverMsg.setEvalEvent(eventMsg); - connection.send(serverMsg.serializeBinary()); - }, - } : undefined, - _Buffer: Buffer, - require: typeof __non_webpack_require__ !== "undefined" ? __non_webpack_require__ : require, - _require: typeof __non_webpack_require__ !== "undefined" ? __non_webpack_require__ : require, - setTimeout, - }, { + onDispose(); + }; + + let eventEmitter = message.getActive() ? new EventEmitter(): undefined; + const sandbox = { + eventEmitter: eventEmitter ? { + // tslint:disable no-any + on: (event: string, cb: (...args: any[]) => void): void => { + eventEmitter!.on(event, (...args: any[]) => { + logger.trace(() => [ + `${event}`, + field("id", message.getId()), + field("args", args.map(stringify)), + ]); + cb(...args); + }); + }, + emit: (event: string, ...args: any[]): void => { + logger.trace(() => [ + `emit ${event}`, + field("id", message.getId()), + field("args", args.map(stringify)), + ]); + const eventMsg = new EvalEventMessage(); + eventMsg.setEvent(event); + eventMsg.setArgsList(args.map(stringify)); + eventMsg.setId(message.getId()); + const serverMsg = new ServerMessage(); + serverMsg.setEvalEvent(eventMsg); + connection.send(serverMsg.serializeBinary()); + }, + // tslint:enable no-any + } : undefined, + _Buffer: Buffer, + require: typeof __non_webpack_require__ !== "undefined" ? __non_webpack_require__ : require, + setTimeout, + setInterval, + clearTimeout, + process: { + env: process.env, + }, + }; + + let value: any; // tslint:disable-line no-any + try { + const code = `(${message.getFunction()})(${eventEmitter ? "eventEmitter, " : ""}${argStr.join(",")});`; + value = vm.runInNewContext(code, sandbox, { + // If the code takes longer than this to return, it is killed and throws. timeout: message.getTimeout() || 15000, }); - if (eventEmitter) { - // Is an active evaluation and should NOT be ended - eventEmitter.on("close", () => onDispose()); - eventEmitter.on("error", () => onDispose()); - } else { - if ((value as Promise).then) { - // Is promise - (value as Promise).then(r => sendResp(r)).catch(ex => sendErr(EvalFailedMessage.Reason.EXCEPTION, ex.toString())); - } else { - sendResp(value); - } - onDispose(); - } } catch (ex) { - sendErr(EvalFailedMessage.Reason.EXCEPTION, ex.toString() + " " + ex.stack); + sendException(ex); + } + + // An evaluation completes when the value it returns resolves. An active + // evaluation completes when it is disposed. Active evaluations are required + // to return disposers so we can know both when it has ended (so we can clean + // up on our end) and how to force end it (for example when the client + // disconnects). + // tslint:disable-next-line no-any + const promise = !eventEmitter ? value as Promise : new Promise((resolve): void => { + value.onDidDispose(resolve); + }); + if (promise && promise.then) { + promise.then(sendResp).catch(sendException); + } else { + sendResp(value); } return eventEmitter ? { onEvent: (eventMsg: EvalEventMessage): void => { - eventEmitter!.emit(eventMsg.getEvent(), ...eventMsg.getArgsList().map(a => JSON.parse(a))); + eventEmitter!.emit(eventMsg.getEvent(), ...eventMsg.getArgsList().map(parse)); + }, + dispose: (): void => { + if (eventEmitter) { + if (value && value.dispose) { + value.dispose(); + } + eventEmitter.removeAllListeners(); + eventEmitter = undefined; + } }, } : undefined; }; diff --git a/packages/protocol/src/node/server.ts b/packages/protocol/src/node/server.ts index e966146b8..448390f25 100644 --- a/packages/protocol/src/node/server.ts +++ b/packages/protocol/src/node/server.ts @@ -1,32 +1,21 @@ import * as os from "os"; -import * as cp from "child_process"; import * as path from "path"; import { mkdir } from "fs"; import { promisify } from "util"; -import { TextDecoder } from "text-encoding"; import { logger, field } from "@coder/logger"; -import { ClientMessage, WorkingInitMessage, ServerMessage, NewSessionMessage, WriteToSessionMessage } from "../proto"; +import { ClientMessage, WorkingInitMessage, ServerMessage } from "../proto"; import { evaluate, ActiveEvaluation } from "./evaluate"; import { ReadWriteConnection } from "../common/connection"; -import { Process, handleNewSession, handleNewConnection, handleNewServer } from "./command"; -import * as net from "net"; export interface ServerOptions { readonly workingDirectory: string; readonly dataDirectory: string; readonly builtInExtensionsDirectory: string; - - forkProvider?(message: NewSessionMessage): cp.ChildProcess; } export class Server { - private readonly sessions = new Map(); - private readonly connections = new Map(); - private readonly servers = new Map(); private readonly evals = new Map(); - private connectionId = Number.MAX_SAFE_INTEGER; - public constructor( private readonly connection: ReadWriteConnection, private readonly options?: ServerOptions, @@ -42,18 +31,10 @@ export class Server { } }); connection.onClose(() => { - this.sessions.forEach((s) => { - s.kill(); - }); - this.connections.forEach((c) => { - c.destroy(); - }); - this.servers.forEach((s) => { - s.close(); - }); + this.evals.forEach((e) => e.dispose()); }); - if (!options) { + if (!this.options) { logger.warn("No server options provided. InitMessage will not be sent."); return; @@ -74,16 +55,16 @@ export class Server { } } }; - Promise.all([ mkdirP(path.join(options.dataDirectory, "User", "workspaceStorage")) ]).then(() => { + Promise.all([ mkdirP(path.join(this.options.dataDirectory, "User", "workspaceStorage")) ]).then(() => { logger.info("Created data directory"); }).catch((error) => { logger.error(error.message, field("error", error)); }); const initMsg = new WorkingInitMessage(); - initMsg.setDataDirectory(options.dataDirectory); - initMsg.setWorkingDirectory(options.workingDirectory); - initMsg.setBuiltinExtensionsDir(options.builtInExtensionsDirectory); + initMsg.setDataDirectory(this.options.dataDirectory); + initMsg.setWorkingDirectory(this.options.workingDirectory); + initMsg.setBuiltinExtensionsDir(this.options.builtInExtensionsDirectory); initMsg.setHomeDirectory(os.homedir()); initMsg.setTmpDirectory(os.tmpdir()); const platform = os.platform(); @@ -113,7 +94,7 @@ export class Server { private handleMessage(message: ClientMessage): void { if (message.hasNewEval()) { const evalMessage = message.getNewEval()!; - logger.debug(() => [ + logger.trace(() => [ "EvalMessage", field("id", evalMessage.getId()), field("args", evalMessage.getArgsList()), @@ -121,132 +102,22 @@ export class Server { ]); const resp = evaluate(this.connection, evalMessage, () => { this.evals.delete(evalMessage.getId()); + logger.trace(() => [ + `dispose ${evalMessage.getId()}, ${this.evals.size} left`, + ]); }); if (resp) { this.evals.set(evalMessage.getId(), resp); } } else if (message.hasEvalEvent()) { const evalEventMessage = message.getEvalEvent()!; - logger.debug("EvalEventMessage", field("id", evalEventMessage.getId())); const e = this.evals.get(evalEventMessage.getId()); if (!e) { return; } e.onEvent(evalEventMessage); - } else if (message.hasNewSession()) { - const sessionMessage = message.getNewSession()!; - logger.debug("NewSession", field("id", sessionMessage.getId())); - const session = handleNewSession(this.connection, sessionMessage, this.options, () => { - this.sessions.delete(sessionMessage.getId()); - }); - this.sessions.set(sessionMessage.getId(), session); - } else if (message.hasCloseSessionInput()) { - const closeSessionMessage = message.getCloseSessionInput()!; - logger.debug("CloseSessionInput", field("id", closeSessionMessage.getId())); - const s = this.getSession(closeSessionMessage.getId()); - if (!s || !s.stdin) { - return; - } - s.stdin.end(); - } else if (message.hasResizeSessionTty()) { - const resizeSessionTtyMessage = message.getResizeSessionTty()!; - logger.debug("ResizeSessionTty", field("id", resizeSessionTtyMessage.getId())); - const s = this.getSession(resizeSessionTtyMessage.getId()); - if (!s || !s.resize) { - return; - } - const tty = resizeSessionTtyMessage.getTtyDimensions()!; - s.resize(tty.getWidth(), tty.getHeight()); - } else if (message.hasShutdownSession()) { - const shutdownSessionMessage = message.getShutdownSession()!; - logger.debug("ShutdownSession", field("id", shutdownSessionMessage.getId())); - const s = this.getSession(shutdownSessionMessage.getId()); - if (!s) { - return; - } - s.kill(shutdownSessionMessage.getSignal()); - } else if (message.hasWriteToSession()) { - const writeToSessionMessage = message.getWriteToSession()!; - logger.debug("WriteToSession", field("id", writeToSessionMessage.getId())); - const s = this.getSession(writeToSessionMessage.getId()); - if (!s) { - return; - } - const data = new TextDecoder().decode(writeToSessionMessage.getData_asU8()); - const source = writeToSessionMessage.getSource(); - if (source === WriteToSessionMessage.Source.IPC) { - if (!s.send) { - throw new Error("Cannot send message via IPC to process without IPC"); - } - s.send(JSON.parse(data)); - } else { - s.write(data); - } - } else if (message.hasNewConnection()) { - const connectionMessage = message.getNewConnection()!; - logger.debug("NewConnection", field("id", connectionMessage.getId())); - if (this.connections.has(connectionMessage.getId())) { - throw new Error(`connect EISCONN ${connectionMessage.getPath() || connectionMessage.getPort()}`); - } - const socket = handleNewConnection(this.connection, connectionMessage, () => { - this.connections.delete(connectionMessage.getId()); - }); - this.connections.set(connectionMessage.getId(), socket); - } else if (message.hasConnectionOutput()) { - const connectionOutputMessage = message.getConnectionOutput()!; - logger.debug("ConnectionOuput", field("id", connectionOutputMessage.getId())); - const c = this.getConnection(connectionOutputMessage.getId()); - if (!c) { - return; - } - c.write(Buffer.from(connectionOutputMessage.getData_asU8())); - } else if (message.hasConnectionClose()) { - const connectionCloseMessage = message.getConnectionClose()!; - logger.debug("ConnectionClose", field("id", connectionCloseMessage.getId())); - const c = this.getConnection(connectionCloseMessage.getId()); - if (!c) { - return; - } - c.end(); - } else if (message.hasNewServer()) { - const serverMessage = message.getNewServer()!; - logger.debug("NewServer", field("id", serverMessage.getId())); - if (this.servers.has(serverMessage.getId())) { - throw new Error("multiple listeners not supported"); - } - const s = handleNewServer(this.connection, serverMessage, (socket) => { - const id = this.connectionId--; - this.connections.set(id, socket); - - return id; - }, () => { - this.connections.delete(serverMessage.getId()); - }, (id) => { - this.connections.delete(id); - }); - this.servers.set(serverMessage.getId(), s); - } else if (message.hasServerClose()) { - const serverCloseMessage = message.getServerClose()!; - logger.debug("ServerClose", field("id", serverCloseMessage.getId())); - const s = this.getServer(serverCloseMessage.getId()); - if (!s) { - return; - } - s.close(); } else { - logger.debug("Received unknown message type"); + throw new Error("unknown message type"); } } - - private getServer(id: number): net.Server | undefined { - return this.servers.get(id); - } - - private getConnection(id: number): net.Socket | undefined { - return this.connections.get(id); - } - - private getSession(id: number): Process | undefined { - return this.sessions.get(id); - } } diff --git a/packages/protocol/src/proto/client.proto b/packages/protocol/src/proto/client.proto index 354fe5ac0..b8d624573 100644 --- a/packages/protocol/src/proto/client.proto +++ b/packages/protocol/src/proto/client.proto @@ -1,22 +1,9 @@ syntax = "proto3"; -import "command.proto"; import "node.proto"; import "vscode.proto"; message ClientMessage { oneof msg { - // command.proto - NewSessionMessage new_session = 1; - ShutdownSessionMessage shutdown_session = 2; - WriteToSessionMessage write_to_session = 3; - CloseSessionInputMessage close_session_input = 4; - ResizeSessionTTYMessage resize_session_tty = 5; - NewConnectionMessage new_connection = 6; - ConnectionOutputMessage connection_output = 7; - ConnectionCloseMessage connection_close = 8; - NewServerMessage new_server = 9; - ServerCloseMessage server_close = 10; - // node.proto NewEvalMessage new_eval = 11; EvalEventMessage eval_event = 12; @@ -25,20 +12,6 @@ message ClientMessage { message ServerMessage { oneof msg { - // command.proto - NewSessionFailureMessage new_session_failure = 1; - SessionDoneMessage session_done = 2; - SessionOutputMessage session_output = 3; - IdentifySessionMessage identify_session = 4; - NewConnectionFailureMessage connection_failure = 5; - ConnectionOutputMessage connection_output = 6; - ConnectionCloseMessage connection_close = 7; - ConnectionEstablishedMessage connection_established = 8; - NewServerFailureMessage server_failure = 9; - ServerEstablishedMessage server_established = 10; - ServerCloseMessage server_close = 11; - ServerConnectionEstablishedMessage server_connection_established = 12; - // node.proto EvalFailedMessage eval_failed = 13; EvalDoneMessage eval_done = 14; diff --git a/packages/protocol/src/proto/client_pb.d.ts b/packages/protocol/src/proto/client_pb.d.ts index f8b653322..2f91ebfd7 100644 --- a/packages/protocol/src/proto/client_pb.d.ts +++ b/packages/protocol/src/proto/client_pb.d.ts @@ -2,61 +2,10 @@ // file: client.proto import * as jspb from "google-protobuf"; -import * as command_pb from "./command_pb"; import * as node_pb from "./node_pb"; import * as vscode_pb from "./vscode_pb"; export class ClientMessage extends jspb.Message { - hasNewSession(): boolean; - clearNewSession(): void; - getNewSession(): command_pb.NewSessionMessage | undefined; - setNewSession(value?: command_pb.NewSessionMessage): void; - - hasShutdownSession(): boolean; - clearShutdownSession(): void; - getShutdownSession(): command_pb.ShutdownSessionMessage | undefined; - setShutdownSession(value?: command_pb.ShutdownSessionMessage): void; - - hasWriteToSession(): boolean; - clearWriteToSession(): void; - getWriteToSession(): command_pb.WriteToSessionMessage | undefined; - setWriteToSession(value?: command_pb.WriteToSessionMessage): void; - - hasCloseSessionInput(): boolean; - clearCloseSessionInput(): void; - getCloseSessionInput(): command_pb.CloseSessionInputMessage | undefined; - setCloseSessionInput(value?: command_pb.CloseSessionInputMessage): void; - - hasResizeSessionTty(): boolean; - clearResizeSessionTty(): void; - getResizeSessionTty(): command_pb.ResizeSessionTTYMessage | undefined; - setResizeSessionTty(value?: command_pb.ResizeSessionTTYMessage): void; - - hasNewConnection(): boolean; - clearNewConnection(): void; - getNewConnection(): command_pb.NewConnectionMessage | undefined; - setNewConnection(value?: command_pb.NewConnectionMessage): void; - - hasConnectionOutput(): boolean; - clearConnectionOutput(): void; - getConnectionOutput(): command_pb.ConnectionOutputMessage | undefined; - setConnectionOutput(value?: command_pb.ConnectionOutputMessage): void; - - hasConnectionClose(): boolean; - clearConnectionClose(): void; - getConnectionClose(): command_pb.ConnectionCloseMessage | undefined; - setConnectionClose(value?: command_pb.ConnectionCloseMessage): void; - - hasNewServer(): boolean; - clearNewServer(): void; - getNewServer(): command_pb.NewServerMessage | undefined; - setNewServer(value?: command_pb.NewServerMessage): void; - - hasServerClose(): boolean; - clearServerClose(): void; - getServerClose(): command_pb.ServerCloseMessage | undefined; - setServerClose(value?: command_pb.ServerCloseMessage): void; - hasNewEval(): boolean; clearNewEval(): void; getNewEval(): node_pb.NewEvalMessage | undefined; @@ -80,98 +29,18 @@ export class ClientMessage extends jspb.Message { export namespace ClientMessage { export type AsObject = { - newSession?: command_pb.NewSessionMessage.AsObject, - shutdownSession?: command_pb.ShutdownSessionMessage.AsObject, - writeToSession?: command_pb.WriteToSessionMessage.AsObject, - closeSessionInput?: command_pb.CloseSessionInputMessage.AsObject, - resizeSessionTty?: command_pb.ResizeSessionTTYMessage.AsObject, - newConnection?: command_pb.NewConnectionMessage.AsObject, - connectionOutput?: command_pb.ConnectionOutputMessage.AsObject, - connectionClose?: command_pb.ConnectionCloseMessage.AsObject, - newServer?: command_pb.NewServerMessage.AsObject, - serverClose?: command_pb.ServerCloseMessage.AsObject, newEval?: node_pb.NewEvalMessage.AsObject, evalEvent?: node_pb.EvalEventMessage.AsObject, } export enum MsgCase { MSG_NOT_SET = 0, - NEW_SESSION = 1, - SHUTDOWN_SESSION = 2, - WRITE_TO_SESSION = 3, - CLOSE_SESSION_INPUT = 4, - RESIZE_SESSION_TTY = 5, - NEW_CONNECTION = 6, - CONNECTION_OUTPUT = 7, - CONNECTION_CLOSE = 8, - NEW_SERVER = 9, - SERVER_CLOSE = 10, NEW_EVAL = 11, EVAL_EVENT = 12, } } export class ServerMessage extends jspb.Message { - hasNewSessionFailure(): boolean; - clearNewSessionFailure(): void; - getNewSessionFailure(): command_pb.NewSessionFailureMessage | undefined; - setNewSessionFailure(value?: command_pb.NewSessionFailureMessage): void; - - hasSessionDone(): boolean; - clearSessionDone(): void; - getSessionDone(): command_pb.SessionDoneMessage | undefined; - setSessionDone(value?: command_pb.SessionDoneMessage): void; - - hasSessionOutput(): boolean; - clearSessionOutput(): void; - getSessionOutput(): command_pb.SessionOutputMessage | undefined; - setSessionOutput(value?: command_pb.SessionOutputMessage): void; - - hasIdentifySession(): boolean; - clearIdentifySession(): void; - getIdentifySession(): command_pb.IdentifySessionMessage | undefined; - setIdentifySession(value?: command_pb.IdentifySessionMessage): void; - - hasConnectionFailure(): boolean; - clearConnectionFailure(): void; - getConnectionFailure(): command_pb.NewConnectionFailureMessage | undefined; - setConnectionFailure(value?: command_pb.NewConnectionFailureMessage): void; - - hasConnectionOutput(): boolean; - clearConnectionOutput(): void; - getConnectionOutput(): command_pb.ConnectionOutputMessage | undefined; - setConnectionOutput(value?: command_pb.ConnectionOutputMessage): void; - - hasConnectionClose(): boolean; - clearConnectionClose(): void; - getConnectionClose(): command_pb.ConnectionCloseMessage | undefined; - setConnectionClose(value?: command_pb.ConnectionCloseMessage): void; - - hasConnectionEstablished(): boolean; - clearConnectionEstablished(): void; - getConnectionEstablished(): command_pb.ConnectionEstablishedMessage | undefined; - setConnectionEstablished(value?: command_pb.ConnectionEstablishedMessage): void; - - hasServerFailure(): boolean; - clearServerFailure(): void; - getServerFailure(): command_pb.NewServerFailureMessage | undefined; - setServerFailure(value?: command_pb.NewServerFailureMessage): void; - - hasServerEstablished(): boolean; - clearServerEstablished(): void; - getServerEstablished(): command_pb.ServerEstablishedMessage | undefined; - setServerEstablished(value?: command_pb.ServerEstablishedMessage): void; - - hasServerClose(): boolean; - clearServerClose(): void; - getServerClose(): command_pb.ServerCloseMessage | undefined; - setServerClose(value?: command_pb.ServerCloseMessage): void; - - hasServerConnectionEstablished(): boolean; - clearServerConnectionEstablished(): void; - getServerConnectionEstablished(): command_pb.ServerConnectionEstablishedMessage | undefined; - setServerConnectionEstablished(value?: command_pb.ServerConnectionEstablishedMessage): void; - hasEvalFailed(): boolean; clearEvalFailed(): void; getEvalFailed(): node_pb.EvalFailedMessage | undefined; @@ -210,18 +79,6 @@ export class ServerMessage extends jspb.Message { export namespace ServerMessage { export type AsObject = { - newSessionFailure?: command_pb.NewSessionFailureMessage.AsObject, - sessionDone?: command_pb.SessionDoneMessage.AsObject, - sessionOutput?: command_pb.SessionOutputMessage.AsObject, - identifySession?: command_pb.IdentifySessionMessage.AsObject, - connectionFailure?: command_pb.NewConnectionFailureMessage.AsObject, - connectionOutput?: command_pb.ConnectionOutputMessage.AsObject, - connectionClose?: command_pb.ConnectionCloseMessage.AsObject, - connectionEstablished?: command_pb.ConnectionEstablishedMessage.AsObject, - serverFailure?: command_pb.NewServerFailureMessage.AsObject, - serverEstablished?: command_pb.ServerEstablishedMessage.AsObject, - serverClose?: command_pb.ServerCloseMessage.AsObject, - serverConnectionEstablished?: command_pb.ServerConnectionEstablishedMessage.AsObject, evalFailed?: node_pb.EvalFailedMessage.AsObject, evalDone?: node_pb.EvalDoneMessage.AsObject, evalEvent?: node_pb.EvalEventMessage.AsObject, @@ -231,18 +88,6 @@ export namespace ServerMessage { export enum MsgCase { MSG_NOT_SET = 0, - NEW_SESSION_FAILURE = 1, - SESSION_DONE = 2, - SESSION_OUTPUT = 3, - IDENTIFY_SESSION = 4, - CONNECTION_FAILURE = 5, - CONNECTION_OUTPUT = 6, - CONNECTION_CLOSE = 7, - CONNECTION_ESTABLISHED = 8, - SERVER_FAILURE = 9, - SERVER_ESTABLISHED = 10, - SERVER_CLOSE = 11, - SERVER_CONNECTION_ESTABLISHED = 12, EVAL_FAILED = 13, EVAL_DONE = 14, EVAL_EVENT = 15, diff --git a/packages/protocol/src/proto/client_pb.js b/packages/protocol/src/proto/client_pb.js index 42623f619..798ac2034 100644 --- a/packages/protocol/src/proto/client_pb.js +++ b/packages/protocol/src/proto/client_pb.js @@ -1,6 +1,8 @@ /** * @fileoverview * @enhanceable + * @suppress {messageConventions} JS Compiler reports an error if a variable or + * field starts with 'MSG_' and isn't a translatable message. * @public */ // GENERATED CODE -- DO NOT EDIT! @@ -9,7 +11,6 @@ var jspb = require('google-protobuf'); var goog = jspb; var global = Function('return this')(); -var command_pb = require('./command_pb.js'); var node_pb = require('./node_pb.js'); var vscode_pb = require('./vscode_pb.js'); goog.exportSymbol('proto.ClientMessage', null, global); @@ -42,23 +43,13 @@ if (goog.DEBUG && !COMPILED) { * @private {!Array>} * @const */ -proto.ClientMessage.oneofGroups_ = [[1,2,3,4,5,6,7,8,9,10,11,12]]; +proto.ClientMessage.oneofGroups_ = [[11,12]]; /** * @enum {number} */ proto.ClientMessage.MsgCase = { MSG_NOT_SET: 0, - NEW_SESSION: 1, - SHUTDOWN_SESSION: 2, - WRITE_TO_SESSION: 3, - CLOSE_SESSION_INPUT: 4, - RESIZE_SESSION_TTY: 5, - NEW_CONNECTION: 6, - CONNECTION_OUTPUT: 7, - CONNECTION_CLOSE: 8, - NEW_SERVER: 9, - SERVER_CLOSE: 10, NEW_EVAL: 11, EVAL_EVENT: 12 }; @@ -95,19 +86,10 @@ proto.ClientMessage.prototype.toObject = function(opt_includeInstance) { * http://goto/soy-param-migration * @param {!proto.ClientMessage} msg The msg instance to transform. * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages */ proto.ClientMessage.toObject = function(includeInstance, msg) { var f, obj = { - newSession: (f = msg.getNewSession()) && command_pb.NewSessionMessage.toObject(includeInstance, f), - shutdownSession: (f = msg.getShutdownSession()) && command_pb.ShutdownSessionMessage.toObject(includeInstance, f), - writeToSession: (f = msg.getWriteToSession()) && command_pb.WriteToSessionMessage.toObject(includeInstance, f), - closeSessionInput: (f = msg.getCloseSessionInput()) && command_pb.CloseSessionInputMessage.toObject(includeInstance, f), - resizeSessionTty: (f = msg.getResizeSessionTty()) && command_pb.ResizeSessionTTYMessage.toObject(includeInstance, f), - newConnection: (f = msg.getNewConnection()) && command_pb.NewConnectionMessage.toObject(includeInstance, f), - connectionOutput: (f = msg.getConnectionOutput()) && command_pb.ConnectionOutputMessage.toObject(includeInstance, f), - connectionClose: (f = msg.getConnectionClose()) && command_pb.ConnectionCloseMessage.toObject(includeInstance, f), - newServer: (f = msg.getNewServer()) && command_pb.NewServerMessage.toObject(includeInstance, f), - serverClose: (f = msg.getServerClose()) && command_pb.ServerCloseMessage.toObject(includeInstance, f), newEval: (f = msg.getNewEval()) && node_pb.NewEvalMessage.toObject(includeInstance, f), evalEvent: (f = msg.getEvalEvent()) && node_pb.EvalEventMessage.toObject(includeInstance, f) }; @@ -146,56 +128,6 @@ proto.ClientMessage.deserializeBinaryFromReader = function(msg, reader) { } var field = reader.getFieldNumber(); switch (field) { - case 1: - var value = new command_pb.NewSessionMessage; - reader.readMessage(value,command_pb.NewSessionMessage.deserializeBinaryFromReader); - msg.setNewSession(value); - break; - case 2: - var value = new command_pb.ShutdownSessionMessage; - reader.readMessage(value,command_pb.ShutdownSessionMessage.deserializeBinaryFromReader); - msg.setShutdownSession(value); - break; - case 3: - var value = new command_pb.WriteToSessionMessage; - reader.readMessage(value,command_pb.WriteToSessionMessage.deserializeBinaryFromReader); - msg.setWriteToSession(value); - break; - case 4: - var value = new command_pb.CloseSessionInputMessage; - reader.readMessage(value,command_pb.CloseSessionInputMessage.deserializeBinaryFromReader); - msg.setCloseSessionInput(value); - break; - case 5: - var value = new command_pb.ResizeSessionTTYMessage; - reader.readMessage(value,command_pb.ResizeSessionTTYMessage.deserializeBinaryFromReader); - msg.setResizeSessionTty(value); - break; - case 6: - var value = new command_pb.NewConnectionMessage; - reader.readMessage(value,command_pb.NewConnectionMessage.deserializeBinaryFromReader); - msg.setNewConnection(value); - break; - case 7: - var value = new command_pb.ConnectionOutputMessage; - reader.readMessage(value,command_pb.ConnectionOutputMessage.deserializeBinaryFromReader); - msg.setConnectionOutput(value); - break; - case 8: - var value = new command_pb.ConnectionCloseMessage; - reader.readMessage(value,command_pb.ConnectionCloseMessage.deserializeBinaryFromReader); - msg.setConnectionClose(value); - break; - case 9: - var value = new command_pb.NewServerMessage; - reader.readMessage(value,command_pb.NewServerMessage.deserializeBinaryFromReader); - msg.setNewServer(value); - break; - case 10: - var value = new command_pb.ServerCloseMessage; - reader.readMessage(value,command_pb.ServerCloseMessage.deserializeBinaryFromReader); - msg.setServerClose(value); - break; case 11: var value = new node_pb.NewEvalMessage; reader.readMessage(value,node_pb.NewEvalMessage.deserializeBinaryFromReader); @@ -215,116 +147,27 @@ proto.ClientMessage.deserializeBinaryFromReader = function(msg, reader) { }; -/** - * Class method variant: serializes the given message to binary data - * (in protobuf wire format), writing to the given BinaryWriter. - * @param {!proto.ClientMessage} message - * @param {!jspb.BinaryWriter} writer - */ -proto.ClientMessage.serializeBinaryToWriter = function(message, writer) { - message.serializeBinaryToWriter(writer); -}; - - /** * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ proto.ClientMessage.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - this.serializeBinaryToWriter(writer); + proto.ClientMessage.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; /** - * Serializes the message to binary data (in protobuf wire format), - * writing to the given BinaryWriter. + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.ClientMessage} message * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.ClientMessage.prototype.serializeBinaryToWriter = function (writer) { +proto.ClientMessage.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = this.getNewSession(); - if (f != null) { - writer.writeMessage( - 1, - f, - command_pb.NewSessionMessage.serializeBinaryToWriter - ); - } - f = this.getShutdownSession(); - if (f != null) { - writer.writeMessage( - 2, - f, - command_pb.ShutdownSessionMessage.serializeBinaryToWriter - ); - } - f = this.getWriteToSession(); - if (f != null) { - writer.writeMessage( - 3, - f, - command_pb.WriteToSessionMessage.serializeBinaryToWriter - ); - } - f = this.getCloseSessionInput(); - if (f != null) { - writer.writeMessage( - 4, - f, - command_pb.CloseSessionInputMessage.serializeBinaryToWriter - ); - } - f = this.getResizeSessionTty(); - if (f != null) { - writer.writeMessage( - 5, - f, - command_pb.ResizeSessionTTYMessage.serializeBinaryToWriter - ); - } - f = this.getNewConnection(); - if (f != null) { - writer.writeMessage( - 6, - f, - command_pb.NewConnectionMessage.serializeBinaryToWriter - ); - } - f = this.getConnectionOutput(); - if (f != null) { - writer.writeMessage( - 7, - f, - command_pb.ConnectionOutputMessage.serializeBinaryToWriter - ); - } - f = this.getConnectionClose(); - if (f != null) { - writer.writeMessage( - 8, - f, - command_pb.ConnectionCloseMessage.serializeBinaryToWriter - ); - } - f = this.getNewServer(); - if (f != null) { - writer.writeMessage( - 9, - f, - command_pb.NewServerMessage.serializeBinaryToWriter - ); - } - f = this.getServerClose(); - if (f != null) { - writer.writeMessage( - 10, - f, - command_pb.ServerCloseMessage.serializeBinaryToWriter - ); - } - f = this.getNewEval(); + f = message.getNewEval(); if (f != null) { writer.writeMessage( 11, @@ -332,7 +175,7 @@ proto.ClientMessage.prototype.serializeBinaryToWriter = function (writer) { node_pb.NewEvalMessage.serializeBinaryToWriter ); } - f = this.getEvalEvent(); + f = message.getEvalEvent(); if (f != null) { writer.writeMessage( 12, @@ -343,326 +186,17 @@ proto.ClientMessage.prototype.serializeBinaryToWriter = function (writer) { }; -/** - * Creates a deep clone of this proto. No data is shared with the original. - * @return {!proto.ClientMessage} The clone. - */ -proto.ClientMessage.prototype.cloneMessage = function() { - return /** @type {!proto.ClientMessage} */ (jspb.Message.cloneMessage(this)); -}; - - -/** - * optional NewSessionMessage new_session = 1; - * @return {proto.NewSessionMessage} - */ -proto.ClientMessage.prototype.getNewSession = function() { - return /** @type{proto.NewSessionMessage} */ ( - jspb.Message.getWrapperField(this, command_pb.NewSessionMessage, 1)); -}; - - -/** @param {proto.NewSessionMessage|undefined} value */ -proto.ClientMessage.prototype.setNewSession = function(value) { - jspb.Message.setOneofWrapperField(this, 1, proto.ClientMessage.oneofGroups_[0], value); -}; - - -proto.ClientMessage.prototype.clearNewSession = function() { - this.setNewSession(undefined); -}; - - -/** - * Returns whether this field is set. - * @return{!boolean} - */ -proto.ClientMessage.prototype.hasNewSession = function() { - return jspb.Message.getField(this, 1) != null; -}; - - -/** - * optional ShutdownSessionMessage shutdown_session = 2; - * @return {proto.ShutdownSessionMessage} - */ -proto.ClientMessage.prototype.getShutdownSession = function() { - return /** @type{proto.ShutdownSessionMessage} */ ( - jspb.Message.getWrapperField(this, command_pb.ShutdownSessionMessage, 2)); -}; - - -/** @param {proto.ShutdownSessionMessage|undefined} value */ -proto.ClientMessage.prototype.setShutdownSession = function(value) { - jspb.Message.setOneofWrapperField(this, 2, proto.ClientMessage.oneofGroups_[0], value); -}; - - -proto.ClientMessage.prototype.clearShutdownSession = function() { - this.setShutdownSession(undefined); -}; - - -/** - * Returns whether this field is set. - * @return{!boolean} - */ -proto.ClientMessage.prototype.hasShutdownSession = function() { - return jspb.Message.getField(this, 2) != null; -}; - - -/** - * optional WriteToSessionMessage write_to_session = 3; - * @return {proto.WriteToSessionMessage} - */ -proto.ClientMessage.prototype.getWriteToSession = function() { - return /** @type{proto.WriteToSessionMessage} */ ( - jspb.Message.getWrapperField(this, command_pb.WriteToSessionMessage, 3)); -}; - - -/** @param {proto.WriteToSessionMessage|undefined} value */ -proto.ClientMessage.prototype.setWriteToSession = function(value) { - jspb.Message.setOneofWrapperField(this, 3, proto.ClientMessage.oneofGroups_[0], value); -}; - - -proto.ClientMessage.prototype.clearWriteToSession = function() { - this.setWriteToSession(undefined); -}; - - -/** - * Returns whether this field is set. - * @return{!boolean} - */ -proto.ClientMessage.prototype.hasWriteToSession = function() { - return jspb.Message.getField(this, 3) != null; -}; - - -/** - * optional CloseSessionInputMessage close_session_input = 4; - * @return {proto.CloseSessionInputMessage} - */ -proto.ClientMessage.prototype.getCloseSessionInput = function() { - return /** @type{proto.CloseSessionInputMessage} */ ( - jspb.Message.getWrapperField(this, command_pb.CloseSessionInputMessage, 4)); -}; - - -/** @param {proto.CloseSessionInputMessage|undefined} value */ -proto.ClientMessage.prototype.setCloseSessionInput = function(value) { - jspb.Message.setOneofWrapperField(this, 4, proto.ClientMessage.oneofGroups_[0], value); -}; - - -proto.ClientMessage.prototype.clearCloseSessionInput = function() { - this.setCloseSessionInput(undefined); -}; - - -/** - * Returns whether this field is set. - * @return{!boolean} - */ -proto.ClientMessage.prototype.hasCloseSessionInput = function() { - return jspb.Message.getField(this, 4) != null; -}; - - -/** - * optional ResizeSessionTTYMessage resize_session_tty = 5; - * @return {proto.ResizeSessionTTYMessage} - */ -proto.ClientMessage.prototype.getResizeSessionTty = function() { - return /** @type{proto.ResizeSessionTTYMessage} */ ( - jspb.Message.getWrapperField(this, command_pb.ResizeSessionTTYMessage, 5)); -}; - - -/** @param {proto.ResizeSessionTTYMessage|undefined} value */ -proto.ClientMessage.prototype.setResizeSessionTty = function(value) { - jspb.Message.setOneofWrapperField(this, 5, proto.ClientMessage.oneofGroups_[0], value); -}; - - -proto.ClientMessage.prototype.clearResizeSessionTty = function() { - this.setResizeSessionTty(undefined); -}; - - -/** - * Returns whether this field is set. - * @return{!boolean} - */ -proto.ClientMessage.prototype.hasResizeSessionTty = function() { - return jspb.Message.getField(this, 5) != null; -}; - - -/** - * optional NewConnectionMessage new_connection = 6; - * @return {proto.NewConnectionMessage} - */ -proto.ClientMessage.prototype.getNewConnection = function() { - return /** @type{proto.NewConnectionMessage} */ ( - jspb.Message.getWrapperField(this, command_pb.NewConnectionMessage, 6)); -}; - - -/** @param {proto.NewConnectionMessage|undefined} value */ -proto.ClientMessage.prototype.setNewConnection = function(value) { - jspb.Message.setOneofWrapperField(this, 6, proto.ClientMessage.oneofGroups_[0], value); -}; - - -proto.ClientMessage.prototype.clearNewConnection = function() { - this.setNewConnection(undefined); -}; - - -/** - * Returns whether this field is set. - * @return{!boolean} - */ -proto.ClientMessage.prototype.hasNewConnection = function() { - return jspb.Message.getField(this, 6) != null; -}; - - -/** - * optional ConnectionOutputMessage connection_output = 7; - * @return {proto.ConnectionOutputMessage} - */ -proto.ClientMessage.prototype.getConnectionOutput = function() { - return /** @type{proto.ConnectionOutputMessage} */ ( - jspb.Message.getWrapperField(this, command_pb.ConnectionOutputMessage, 7)); -}; - - -/** @param {proto.ConnectionOutputMessage|undefined} value */ -proto.ClientMessage.prototype.setConnectionOutput = function(value) { - jspb.Message.setOneofWrapperField(this, 7, proto.ClientMessage.oneofGroups_[0], value); -}; - - -proto.ClientMessage.prototype.clearConnectionOutput = function() { - this.setConnectionOutput(undefined); -}; - - -/** - * Returns whether this field is set. - * @return{!boolean} - */ -proto.ClientMessage.prototype.hasConnectionOutput = function() { - return jspb.Message.getField(this, 7) != null; -}; - - -/** - * optional ConnectionCloseMessage connection_close = 8; - * @return {proto.ConnectionCloseMessage} - */ -proto.ClientMessage.prototype.getConnectionClose = function() { - return /** @type{proto.ConnectionCloseMessage} */ ( - jspb.Message.getWrapperField(this, command_pb.ConnectionCloseMessage, 8)); -}; - - -/** @param {proto.ConnectionCloseMessage|undefined} value */ -proto.ClientMessage.prototype.setConnectionClose = function(value) { - jspb.Message.setOneofWrapperField(this, 8, proto.ClientMessage.oneofGroups_[0], value); -}; - - -proto.ClientMessage.prototype.clearConnectionClose = function() { - this.setConnectionClose(undefined); -}; - - -/** - * Returns whether this field is set. - * @return{!boolean} - */ -proto.ClientMessage.prototype.hasConnectionClose = function() { - return jspb.Message.getField(this, 8) != null; -}; - - -/** - * optional NewServerMessage new_server = 9; - * @return {proto.NewServerMessage} - */ -proto.ClientMessage.prototype.getNewServer = function() { - return /** @type{proto.NewServerMessage} */ ( - jspb.Message.getWrapperField(this, command_pb.NewServerMessage, 9)); -}; - - -/** @param {proto.NewServerMessage|undefined} value */ -proto.ClientMessage.prototype.setNewServer = function(value) { - jspb.Message.setOneofWrapperField(this, 9, proto.ClientMessage.oneofGroups_[0], value); -}; - - -proto.ClientMessage.prototype.clearNewServer = function() { - this.setNewServer(undefined); -}; - - -/** - * Returns whether this field is set. - * @return{!boolean} - */ -proto.ClientMessage.prototype.hasNewServer = function() { - return jspb.Message.getField(this, 9) != null; -}; - - -/** - * optional ServerCloseMessage server_close = 10; - * @return {proto.ServerCloseMessage} - */ -proto.ClientMessage.prototype.getServerClose = function() { - return /** @type{proto.ServerCloseMessage} */ ( - jspb.Message.getWrapperField(this, command_pb.ServerCloseMessage, 10)); -}; - - -/** @param {proto.ServerCloseMessage|undefined} value */ -proto.ClientMessage.prototype.setServerClose = function(value) { - jspb.Message.setOneofWrapperField(this, 10, proto.ClientMessage.oneofGroups_[0], value); -}; - - -proto.ClientMessage.prototype.clearServerClose = function() { - this.setServerClose(undefined); -}; - - -/** - * Returns whether this field is set. - * @return{!boolean} - */ -proto.ClientMessage.prototype.hasServerClose = function() { - return jspb.Message.getField(this, 10) != null; -}; - - /** * optional NewEvalMessage new_eval = 11; - * @return {proto.NewEvalMessage} + * @return {?proto.NewEvalMessage} */ proto.ClientMessage.prototype.getNewEval = function() { - return /** @type{proto.NewEvalMessage} */ ( + return /** @type{?proto.NewEvalMessage} */ ( jspb.Message.getWrapperField(this, node_pb.NewEvalMessage, 11)); }; -/** @param {proto.NewEvalMessage|undefined} value */ +/** @param {?proto.NewEvalMessage|undefined} value */ proto.ClientMessage.prototype.setNewEval = function(value) { jspb.Message.setOneofWrapperField(this, 11, proto.ClientMessage.oneofGroups_[0], value); }; @@ -675,7 +209,7 @@ proto.ClientMessage.prototype.clearNewEval = function() { /** * Returns whether this field is set. - * @return{!boolean} + * @return {!boolean} */ proto.ClientMessage.prototype.hasNewEval = function() { return jspb.Message.getField(this, 11) != null; @@ -684,15 +218,15 @@ proto.ClientMessage.prototype.hasNewEval = function() { /** * optional EvalEventMessage eval_event = 12; - * @return {proto.EvalEventMessage} + * @return {?proto.EvalEventMessage} */ proto.ClientMessage.prototype.getEvalEvent = function() { - return /** @type{proto.EvalEventMessage} */ ( + return /** @type{?proto.EvalEventMessage} */ ( jspb.Message.getWrapperField(this, node_pb.EvalEventMessage, 12)); }; -/** @param {proto.EvalEventMessage|undefined} value */ +/** @param {?proto.EvalEventMessage|undefined} value */ proto.ClientMessage.prototype.setEvalEvent = function(value) { jspb.Message.setOneofWrapperField(this, 12, proto.ClientMessage.oneofGroups_[0], value); }; @@ -705,7 +239,7 @@ proto.ClientMessage.prototype.clearEvalEvent = function() { /** * Returns whether this field is set. - * @return{!boolean} + * @return {!boolean} */ proto.ClientMessage.prototype.hasEvalEvent = function() { return jspb.Message.getField(this, 12) != null; @@ -738,25 +272,13 @@ if (goog.DEBUG && !COMPILED) { * @private {!Array>} * @const */ -proto.ServerMessage.oneofGroups_ = [[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17]]; +proto.ServerMessage.oneofGroups_ = [[13,14,15,16,17]]; /** * @enum {number} */ proto.ServerMessage.MsgCase = { MSG_NOT_SET: 0, - NEW_SESSION_FAILURE: 1, - SESSION_DONE: 2, - SESSION_OUTPUT: 3, - IDENTIFY_SESSION: 4, - CONNECTION_FAILURE: 5, - CONNECTION_OUTPUT: 6, - CONNECTION_CLOSE: 7, - CONNECTION_ESTABLISHED: 8, - SERVER_FAILURE: 9, - SERVER_ESTABLISHED: 10, - SERVER_CLOSE: 11, - SERVER_CONNECTION_ESTABLISHED: 12, EVAL_FAILED: 13, EVAL_DONE: 14, EVAL_EVENT: 15, @@ -796,21 +318,10 @@ proto.ServerMessage.prototype.toObject = function(opt_includeInstance) { * http://goto/soy-param-migration * @param {!proto.ServerMessage} msg The msg instance to transform. * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages */ proto.ServerMessage.toObject = function(includeInstance, msg) { var f, obj = { - newSessionFailure: (f = msg.getNewSessionFailure()) && command_pb.NewSessionFailureMessage.toObject(includeInstance, f), - sessionDone: (f = msg.getSessionDone()) && command_pb.SessionDoneMessage.toObject(includeInstance, f), - sessionOutput: (f = msg.getSessionOutput()) && command_pb.SessionOutputMessage.toObject(includeInstance, f), - identifySession: (f = msg.getIdentifySession()) && command_pb.IdentifySessionMessage.toObject(includeInstance, f), - connectionFailure: (f = msg.getConnectionFailure()) && command_pb.NewConnectionFailureMessage.toObject(includeInstance, f), - connectionOutput: (f = msg.getConnectionOutput()) && command_pb.ConnectionOutputMessage.toObject(includeInstance, f), - connectionClose: (f = msg.getConnectionClose()) && command_pb.ConnectionCloseMessage.toObject(includeInstance, f), - connectionEstablished: (f = msg.getConnectionEstablished()) && command_pb.ConnectionEstablishedMessage.toObject(includeInstance, f), - serverFailure: (f = msg.getServerFailure()) && command_pb.NewServerFailureMessage.toObject(includeInstance, f), - serverEstablished: (f = msg.getServerEstablished()) && command_pb.ServerEstablishedMessage.toObject(includeInstance, f), - serverClose: (f = msg.getServerClose()) && command_pb.ServerCloseMessage.toObject(includeInstance, f), - serverConnectionEstablished: (f = msg.getServerConnectionEstablished()) && command_pb.ServerConnectionEstablishedMessage.toObject(includeInstance, f), evalFailed: (f = msg.getEvalFailed()) && node_pb.EvalFailedMessage.toObject(includeInstance, f), evalDone: (f = msg.getEvalDone()) && node_pb.EvalDoneMessage.toObject(includeInstance, f), evalEvent: (f = msg.getEvalEvent()) && node_pb.EvalEventMessage.toObject(includeInstance, f), @@ -852,66 +363,6 @@ proto.ServerMessage.deserializeBinaryFromReader = function(msg, reader) { } var field = reader.getFieldNumber(); switch (field) { - case 1: - var value = new command_pb.NewSessionFailureMessage; - reader.readMessage(value,command_pb.NewSessionFailureMessage.deserializeBinaryFromReader); - msg.setNewSessionFailure(value); - break; - case 2: - var value = new command_pb.SessionDoneMessage; - reader.readMessage(value,command_pb.SessionDoneMessage.deserializeBinaryFromReader); - msg.setSessionDone(value); - break; - case 3: - var value = new command_pb.SessionOutputMessage; - reader.readMessage(value,command_pb.SessionOutputMessage.deserializeBinaryFromReader); - msg.setSessionOutput(value); - break; - case 4: - var value = new command_pb.IdentifySessionMessage; - reader.readMessage(value,command_pb.IdentifySessionMessage.deserializeBinaryFromReader); - msg.setIdentifySession(value); - break; - case 5: - var value = new command_pb.NewConnectionFailureMessage; - reader.readMessage(value,command_pb.NewConnectionFailureMessage.deserializeBinaryFromReader); - msg.setConnectionFailure(value); - break; - case 6: - var value = new command_pb.ConnectionOutputMessage; - reader.readMessage(value,command_pb.ConnectionOutputMessage.deserializeBinaryFromReader); - msg.setConnectionOutput(value); - break; - case 7: - var value = new command_pb.ConnectionCloseMessage; - reader.readMessage(value,command_pb.ConnectionCloseMessage.deserializeBinaryFromReader); - msg.setConnectionClose(value); - break; - case 8: - var value = new command_pb.ConnectionEstablishedMessage; - reader.readMessage(value,command_pb.ConnectionEstablishedMessage.deserializeBinaryFromReader); - msg.setConnectionEstablished(value); - break; - case 9: - var value = new command_pb.NewServerFailureMessage; - reader.readMessage(value,command_pb.NewServerFailureMessage.deserializeBinaryFromReader); - msg.setServerFailure(value); - break; - case 10: - var value = new command_pb.ServerEstablishedMessage; - reader.readMessage(value,command_pb.ServerEstablishedMessage.deserializeBinaryFromReader); - msg.setServerEstablished(value); - break; - case 11: - var value = new command_pb.ServerCloseMessage; - reader.readMessage(value,command_pb.ServerCloseMessage.deserializeBinaryFromReader); - msg.setServerClose(value); - break; - case 12: - var value = new command_pb.ServerConnectionEstablishedMessage; - reader.readMessage(value,command_pb.ServerConnectionEstablishedMessage.deserializeBinaryFromReader); - msg.setServerConnectionEstablished(value); - break; case 13: var value = new node_pb.EvalFailedMessage; reader.readMessage(value,node_pb.EvalFailedMessage.deserializeBinaryFromReader); @@ -946,132 +397,27 @@ proto.ServerMessage.deserializeBinaryFromReader = function(msg, reader) { }; -/** - * Class method variant: serializes the given message to binary data - * (in protobuf wire format), writing to the given BinaryWriter. - * @param {!proto.ServerMessage} message - * @param {!jspb.BinaryWriter} writer - */ -proto.ServerMessage.serializeBinaryToWriter = function(message, writer) { - message.serializeBinaryToWriter(writer); -}; - - /** * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ proto.ServerMessage.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - this.serializeBinaryToWriter(writer); + proto.ServerMessage.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; /** - * Serializes the message to binary data (in protobuf wire format), - * writing to the given BinaryWriter. + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.ServerMessage} message * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.ServerMessage.prototype.serializeBinaryToWriter = function (writer) { +proto.ServerMessage.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = this.getNewSessionFailure(); - if (f != null) { - writer.writeMessage( - 1, - f, - command_pb.NewSessionFailureMessage.serializeBinaryToWriter - ); - } - f = this.getSessionDone(); - if (f != null) { - writer.writeMessage( - 2, - f, - command_pb.SessionDoneMessage.serializeBinaryToWriter - ); - } - f = this.getSessionOutput(); - if (f != null) { - writer.writeMessage( - 3, - f, - command_pb.SessionOutputMessage.serializeBinaryToWriter - ); - } - f = this.getIdentifySession(); - if (f != null) { - writer.writeMessage( - 4, - f, - command_pb.IdentifySessionMessage.serializeBinaryToWriter - ); - } - f = this.getConnectionFailure(); - if (f != null) { - writer.writeMessage( - 5, - f, - command_pb.NewConnectionFailureMessage.serializeBinaryToWriter - ); - } - f = this.getConnectionOutput(); - if (f != null) { - writer.writeMessage( - 6, - f, - command_pb.ConnectionOutputMessage.serializeBinaryToWriter - ); - } - f = this.getConnectionClose(); - if (f != null) { - writer.writeMessage( - 7, - f, - command_pb.ConnectionCloseMessage.serializeBinaryToWriter - ); - } - f = this.getConnectionEstablished(); - if (f != null) { - writer.writeMessage( - 8, - f, - command_pb.ConnectionEstablishedMessage.serializeBinaryToWriter - ); - } - f = this.getServerFailure(); - if (f != null) { - writer.writeMessage( - 9, - f, - command_pb.NewServerFailureMessage.serializeBinaryToWriter - ); - } - f = this.getServerEstablished(); - if (f != null) { - writer.writeMessage( - 10, - f, - command_pb.ServerEstablishedMessage.serializeBinaryToWriter - ); - } - f = this.getServerClose(); - if (f != null) { - writer.writeMessage( - 11, - f, - command_pb.ServerCloseMessage.serializeBinaryToWriter - ); - } - f = this.getServerConnectionEstablished(); - if (f != null) { - writer.writeMessage( - 12, - f, - command_pb.ServerConnectionEstablishedMessage.serializeBinaryToWriter - ); - } - f = this.getEvalFailed(); + f = message.getEvalFailed(); if (f != null) { writer.writeMessage( 13, @@ -1079,7 +425,7 @@ proto.ServerMessage.prototype.serializeBinaryToWriter = function (writer) { node_pb.EvalFailedMessage.serializeBinaryToWriter ); } - f = this.getEvalDone(); + f = message.getEvalDone(); if (f != null) { writer.writeMessage( 14, @@ -1087,7 +433,7 @@ proto.ServerMessage.prototype.serializeBinaryToWriter = function (writer) { node_pb.EvalDoneMessage.serializeBinaryToWriter ); } - f = this.getEvalEvent(); + f = message.getEvalEvent(); if (f != null) { writer.writeMessage( 15, @@ -1095,7 +441,7 @@ proto.ServerMessage.prototype.serializeBinaryToWriter = function (writer) { node_pb.EvalEventMessage.serializeBinaryToWriter ); } - f = this.getInit(); + f = message.getInit(); if (f != null) { writer.writeMessage( 16, @@ -1103,7 +449,7 @@ proto.ServerMessage.prototype.serializeBinaryToWriter = function (writer) { proto.WorkingInitMessage.serializeBinaryToWriter ); } - f = this.getSharedProcessActive(); + f = message.getSharedProcessActive(); if (f != null) { writer.writeMessage( 17, @@ -1114,386 +460,17 @@ proto.ServerMessage.prototype.serializeBinaryToWriter = function (writer) { }; -/** - * Creates a deep clone of this proto. No data is shared with the original. - * @return {!proto.ServerMessage} The clone. - */ -proto.ServerMessage.prototype.cloneMessage = function() { - return /** @type {!proto.ServerMessage} */ (jspb.Message.cloneMessage(this)); -}; - - -/** - * optional NewSessionFailureMessage new_session_failure = 1; - * @return {proto.NewSessionFailureMessage} - */ -proto.ServerMessage.prototype.getNewSessionFailure = function() { - return /** @type{proto.NewSessionFailureMessage} */ ( - jspb.Message.getWrapperField(this, command_pb.NewSessionFailureMessage, 1)); -}; - - -/** @param {proto.NewSessionFailureMessage|undefined} value */ -proto.ServerMessage.prototype.setNewSessionFailure = function(value) { - jspb.Message.setOneofWrapperField(this, 1, proto.ServerMessage.oneofGroups_[0], value); -}; - - -proto.ServerMessage.prototype.clearNewSessionFailure = function() { - this.setNewSessionFailure(undefined); -}; - - -/** - * Returns whether this field is set. - * @return{!boolean} - */ -proto.ServerMessage.prototype.hasNewSessionFailure = function() { - return jspb.Message.getField(this, 1) != null; -}; - - -/** - * optional SessionDoneMessage session_done = 2; - * @return {proto.SessionDoneMessage} - */ -proto.ServerMessage.prototype.getSessionDone = function() { - return /** @type{proto.SessionDoneMessage} */ ( - jspb.Message.getWrapperField(this, command_pb.SessionDoneMessage, 2)); -}; - - -/** @param {proto.SessionDoneMessage|undefined} value */ -proto.ServerMessage.prototype.setSessionDone = function(value) { - jspb.Message.setOneofWrapperField(this, 2, proto.ServerMessage.oneofGroups_[0], value); -}; - - -proto.ServerMessage.prototype.clearSessionDone = function() { - this.setSessionDone(undefined); -}; - - -/** - * Returns whether this field is set. - * @return{!boolean} - */ -proto.ServerMessage.prototype.hasSessionDone = function() { - return jspb.Message.getField(this, 2) != null; -}; - - -/** - * optional SessionOutputMessage session_output = 3; - * @return {proto.SessionOutputMessage} - */ -proto.ServerMessage.prototype.getSessionOutput = function() { - return /** @type{proto.SessionOutputMessage} */ ( - jspb.Message.getWrapperField(this, command_pb.SessionOutputMessage, 3)); -}; - - -/** @param {proto.SessionOutputMessage|undefined} value */ -proto.ServerMessage.prototype.setSessionOutput = function(value) { - jspb.Message.setOneofWrapperField(this, 3, proto.ServerMessage.oneofGroups_[0], value); -}; - - -proto.ServerMessage.prototype.clearSessionOutput = function() { - this.setSessionOutput(undefined); -}; - - -/** - * Returns whether this field is set. - * @return{!boolean} - */ -proto.ServerMessage.prototype.hasSessionOutput = function() { - return jspb.Message.getField(this, 3) != null; -}; - - -/** - * optional IdentifySessionMessage identify_session = 4; - * @return {proto.IdentifySessionMessage} - */ -proto.ServerMessage.prototype.getIdentifySession = function() { - return /** @type{proto.IdentifySessionMessage} */ ( - jspb.Message.getWrapperField(this, command_pb.IdentifySessionMessage, 4)); -}; - - -/** @param {proto.IdentifySessionMessage|undefined} value */ -proto.ServerMessage.prototype.setIdentifySession = function(value) { - jspb.Message.setOneofWrapperField(this, 4, proto.ServerMessage.oneofGroups_[0], value); -}; - - -proto.ServerMessage.prototype.clearIdentifySession = function() { - this.setIdentifySession(undefined); -}; - - -/** - * Returns whether this field is set. - * @return{!boolean} - */ -proto.ServerMessage.prototype.hasIdentifySession = function() { - return jspb.Message.getField(this, 4) != null; -}; - - -/** - * optional NewConnectionFailureMessage connection_failure = 5; - * @return {proto.NewConnectionFailureMessage} - */ -proto.ServerMessage.prototype.getConnectionFailure = function() { - return /** @type{proto.NewConnectionFailureMessage} */ ( - jspb.Message.getWrapperField(this, command_pb.NewConnectionFailureMessage, 5)); -}; - - -/** @param {proto.NewConnectionFailureMessage|undefined} value */ -proto.ServerMessage.prototype.setConnectionFailure = function(value) { - jspb.Message.setOneofWrapperField(this, 5, proto.ServerMessage.oneofGroups_[0], value); -}; - - -proto.ServerMessage.prototype.clearConnectionFailure = function() { - this.setConnectionFailure(undefined); -}; - - -/** - * Returns whether this field is set. - * @return{!boolean} - */ -proto.ServerMessage.prototype.hasConnectionFailure = function() { - return jspb.Message.getField(this, 5) != null; -}; - - -/** - * optional ConnectionOutputMessage connection_output = 6; - * @return {proto.ConnectionOutputMessage} - */ -proto.ServerMessage.prototype.getConnectionOutput = function() { - return /** @type{proto.ConnectionOutputMessage} */ ( - jspb.Message.getWrapperField(this, command_pb.ConnectionOutputMessage, 6)); -}; - - -/** @param {proto.ConnectionOutputMessage|undefined} value */ -proto.ServerMessage.prototype.setConnectionOutput = function(value) { - jspb.Message.setOneofWrapperField(this, 6, proto.ServerMessage.oneofGroups_[0], value); -}; - - -proto.ServerMessage.prototype.clearConnectionOutput = function() { - this.setConnectionOutput(undefined); -}; - - -/** - * Returns whether this field is set. - * @return{!boolean} - */ -proto.ServerMessage.prototype.hasConnectionOutput = function() { - return jspb.Message.getField(this, 6) != null; -}; - - -/** - * optional ConnectionCloseMessage connection_close = 7; - * @return {proto.ConnectionCloseMessage} - */ -proto.ServerMessage.prototype.getConnectionClose = function() { - return /** @type{proto.ConnectionCloseMessage} */ ( - jspb.Message.getWrapperField(this, command_pb.ConnectionCloseMessage, 7)); -}; - - -/** @param {proto.ConnectionCloseMessage|undefined} value */ -proto.ServerMessage.prototype.setConnectionClose = function(value) { - jspb.Message.setOneofWrapperField(this, 7, proto.ServerMessage.oneofGroups_[0], value); -}; - - -proto.ServerMessage.prototype.clearConnectionClose = function() { - this.setConnectionClose(undefined); -}; - - -/** - * Returns whether this field is set. - * @return{!boolean} - */ -proto.ServerMessage.prototype.hasConnectionClose = function() { - return jspb.Message.getField(this, 7) != null; -}; - - -/** - * optional ConnectionEstablishedMessage connection_established = 8; - * @return {proto.ConnectionEstablishedMessage} - */ -proto.ServerMessage.prototype.getConnectionEstablished = function() { - return /** @type{proto.ConnectionEstablishedMessage} */ ( - jspb.Message.getWrapperField(this, command_pb.ConnectionEstablishedMessage, 8)); -}; - - -/** @param {proto.ConnectionEstablishedMessage|undefined} value */ -proto.ServerMessage.prototype.setConnectionEstablished = function(value) { - jspb.Message.setOneofWrapperField(this, 8, proto.ServerMessage.oneofGroups_[0], value); -}; - - -proto.ServerMessage.prototype.clearConnectionEstablished = function() { - this.setConnectionEstablished(undefined); -}; - - -/** - * Returns whether this field is set. - * @return{!boolean} - */ -proto.ServerMessage.prototype.hasConnectionEstablished = function() { - return jspb.Message.getField(this, 8) != null; -}; - - -/** - * optional NewServerFailureMessage server_failure = 9; - * @return {proto.NewServerFailureMessage} - */ -proto.ServerMessage.prototype.getServerFailure = function() { - return /** @type{proto.NewServerFailureMessage} */ ( - jspb.Message.getWrapperField(this, command_pb.NewServerFailureMessage, 9)); -}; - - -/** @param {proto.NewServerFailureMessage|undefined} value */ -proto.ServerMessage.prototype.setServerFailure = function(value) { - jspb.Message.setOneofWrapperField(this, 9, proto.ServerMessage.oneofGroups_[0], value); -}; - - -proto.ServerMessage.prototype.clearServerFailure = function() { - this.setServerFailure(undefined); -}; - - -/** - * Returns whether this field is set. - * @return{!boolean} - */ -proto.ServerMessage.prototype.hasServerFailure = function() { - return jspb.Message.getField(this, 9) != null; -}; - - -/** - * optional ServerEstablishedMessage server_established = 10; - * @return {proto.ServerEstablishedMessage} - */ -proto.ServerMessage.prototype.getServerEstablished = function() { - return /** @type{proto.ServerEstablishedMessage} */ ( - jspb.Message.getWrapperField(this, command_pb.ServerEstablishedMessage, 10)); -}; - - -/** @param {proto.ServerEstablishedMessage|undefined} value */ -proto.ServerMessage.prototype.setServerEstablished = function(value) { - jspb.Message.setOneofWrapperField(this, 10, proto.ServerMessage.oneofGroups_[0], value); -}; - - -proto.ServerMessage.prototype.clearServerEstablished = function() { - this.setServerEstablished(undefined); -}; - - -/** - * Returns whether this field is set. - * @return{!boolean} - */ -proto.ServerMessage.prototype.hasServerEstablished = function() { - return jspb.Message.getField(this, 10) != null; -}; - - -/** - * optional ServerCloseMessage server_close = 11; - * @return {proto.ServerCloseMessage} - */ -proto.ServerMessage.prototype.getServerClose = function() { - return /** @type{proto.ServerCloseMessage} */ ( - jspb.Message.getWrapperField(this, command_pb.ServerCloseMessage, 11)); -}; - - -/** @param {proto.ServerCloseMessage|undefined} value */ -proto.ServerMessage.prototype.setServerClose = function(value) { - jspb.Message.setOneofWrapperField(this, 11, proto.ServerMessage.oneofGroups_[0], value); -}; - - -proto.ServerMessage.prototype.clearServerClose = function() { - this.setServerClose(undefined); -}; - - -/** - * Returns whether this field is set. - * @return{!boolean} - */ -proto.ServerMessage.prototype.hasServerClose = function() { - return jspb.Message.getField(this, 11) != null; -}; - - -/** - * optional ServerConnectionEstablishedMessage server_connection_established = 12; - * @return {proto.ServerConnectionEstablishedMessage} - */ -proto.ServerMessage.prototype.getServerConnectionEstablished = function() { - return /** @type{proto.ServerConnectionEstablishedMessage} */ ( - jspb.Message.getWrapperField(this, command_pb.ServerConnectionEstablishedMessage, 12)); -}; - - -/** @param {proto.ServerConnectionEstablishedMessage|undefined} value */ -proto.ServerMessage.prototype.setServerConnectionEstablished = function(value) { - jspb.Message.setOneofWrapperField(this, 12, proto.ServerMessage.oneofGroups_[0], value); -}; - - -proto.ServerMessage.prototype.clearServerConnectionEstablished = function() { - this.setServerConnectionEstablished(undefined); -}; - - -/** - * Returns whether this field is set. - * @return{!boolean} - */ -proto.ServerMessage.prototype.hasServerConnectionEstablished = function() { - return jspb.Message.getField(this, 12) != null; -}; - - /** * optional EvalFailedMessage eval_failed = 13; - * @return {proto.EvalFailedMessage} + * @return {?proto.EvalFailedMessage} */ proto.ServerMessage.prototype.getEvalFailed = function() { - return /** @type{proto.EvalFailedMessage} */ ( + return /** @type{?proto.EvalFailedMessage} */ ( jspb.Message.getWrapperField(this, node_pb.EvalFailedMessage, 13)); }; -/** @param {proto.EvalFailedMessage|undefined} value */ +/** @param {?proto.EvalFailedMessage|undefined} value */ proto.ServerMessage.prototype.setEvalFailed = function(value) { jspb.Message.setOneofWrapperField(this, 13, proto.ServerMessage.oneofGroups_[0], value); }; @@ -1506,7 +483,7 @@ proto.ServerMessage.prototype.clearEvalFailed = function() { /** * Returns whether this field is set. - * @return{!boolean} + * @return {!boolean} */ proto.ServerMessage.prototype.hasEvalFailed = function() { return jspb.Message.getField(this, 13) != null; @@ -1515,15 +492,15 @@ proto.ServerMessage.prototype.hasEvalFailed = function() { /** * optional EvalDoneMessage eval_done = 14; - * @return {proto.EvalDoneMessage} + * @return {?proto.EvalDoneMessage} */ proto.ServerMessage.prototype.getEvalDone = function() { - return /** @type{proto.EvalDoneMessage} */ ( + return /** @type{?proto.EvalDoneMessage} */ ( jspb.Message.getWrapperField(this, node_pb.EvalDoneMessage, 14)); }; -/** @param {proto.EvalDoneMessage|undefined} value */ +/** @param {?proto.EvalDoneMessage|undefined} value */ proto.ServerMessage.prototype.setEvalDone = function(value) { jspb.Message.setOneofWrapperField(this, 14, proto.ServerMessage.oneofGroups_[0], value); }; @@ -1536,7 +513,7 @@ proto.ServerMessage.prototype.clearEvalDone = function() { /** * Returns whether this field is set. - * @return{!boolean} + * @return {!boolean} */ proto.ServerMessage.prototype.hasEvalDone = function() { return jspb.Message.getField(this, 14) != null; @@ -1545,15 +522,15 @@ proto.ServerMessage.prototype.hasEvalDone = function() { /** * optional EvalEventMessage eval_event = 15; - * @return {proto.EvalEventMessage} + * @return {?proto.EvalEventMessage} */ proto.ServerMessage.prototype.getEvalEvent = function() { - return /** @type{proto.EvalEventMessage} */ ( + return /** @type{?proto.EvalEventMessage} */ ( jspb.Message.getWrapperField(this, node_pb.EvalEventMessage, 15)); }; -/** @param {proto.EvalEventMessage|undefined} value */ +/** @param {?proto.EvalEventMessage|undefined} value */ proto.ServerMessage.prototype.setEvalEvent = function(value) { jspb.Message.setOneofWrapperField(this, 15, proto.ServerMessage.oneofGroups_[0], value); }; @@ -1566,7 +543,7 @@ proto.ServerMessage.prototype.clearEvalEvent = function() { /** * Returns whether this field is set. - * @return{!boolean} + * @return {!boolean} */ proto.ServerMessage.prototype.hasEvalEvent = function() { return jspb.Message.getField(this, 15) != null; @@ -1575,15 +552,15 @@ proto.ServerMessage.prototype.hasEvalEvent = function() { /** * optional WorkingInitMessage init = 16; - * @return {proto.WorkingInitMessage} + * @return {?proto.WorkingInitMessage} */ proto.ServerMessage.prototype.getInit = function() { - return /** @type{proto.WorkingInitMessage} */ ( + return /** @type{?proto.WorkingInitMessage} */ ( jspb.Message.getWrapperField(this, proto.WorkingInitMessage, 16)); }; -/** @param {proto.WorkingInitMessage|undefined} value */ +/** @param {?proto.WorkingInitMessage|undefined} value */ proto.ServerMessage.prototype.setInit = function(value) { jspb.Message.setOneofWrapperField(this, 16, proto.ServerMessage.oneofGroups_[0], value); }; @@ -1596,7 +573,7 @@ proto.ServerMessage.prototype.clearInit = function() { /** * Returns whether this field is set. - * @return{!boolean} + * @return {!boolean} */ proto.ServerMessage.prototype.hasInit = function() { return jspb.Message.getField(this, 16) != null; @@ -1605,15 +582,15 @@ proto.ServerMessage.prototype.hasInit = function() { /** * optional SharedProcessActiveMessage shared_process_active = 17; - * @return {proto.SharedProcessActiveMessage} + * @return {?proto.SharedProcessActiveMessage} */ proto.ServerMessage.prototype.getSharedProcessActive = function() { - return /** @type{proto.SharedProcessActiveMessage} */ ( + return /** @type{?proto.SharedProcessActiveMessage} */ ( jspb.Message.getWrapperField(this, vscode_pb.SharedProcessActiveMessage, 17)); }; -/** @param {proto.SharedProcessActiveMessage|undefined} value */ +/** @param {?proto.SharedProcessActiveMessage|undefined} value */ proto.ServerMessage.prototype.setSharedProcessActive = function(value) { jspb.Message.setOneofWrapperField(this, 17, proto.ServerMessage.oneofGroups_[0], value); }; @@ -1626,7 +603,7 @@ proto.ServerMessage.prototype.clearSharedProcessActive = function() { /** * Returns whether this field is set. - * @return{!boolean} + * @return {!boolean} */ proto.ServerMessage.prototype.hasSharedProcessActive = function() { return jspb.Message.getField(this, 17) != null; @@ -1676,16 +653,17 @@ proto.WorkingInitMessage.prototype.toObject = function(opt_includeInstance) { * http://goto/soy-param-migration * @param {!proto.WorkingInitMessage} msg The msg instance to transform. * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages */ proto.WorkingInitMessage.toObject = function(includeInstance, msg) { var f, obj = { - homeDirectory: msg.getHomeDirectory(), - tmpDirectory: msg.getTmpDirectory(), - dataDirectory: msg.getDataDirectory(), - workingDirectory: msg.getWorkingDirectory(), - operatingSystem: msg.getOperatingSystem(), - shell: msg.getShell(), - builtinExtensionsDir: msg.getBuiltinExtensionsDir() + homeDirectory: jspb.Message.getFieldWithDefault(msg, 1, ""), + tmpDirectory: jspb.Message.getFieldWithDefault(msg, 2, ""), + dataDirectory: jspb.Message.getFieldWithDefault(msg, 3, ""), + workingDirectory: jspb.Message.getFieldWithDefault(msg, 4, ""), + operatingSystem: jspb.Message.getFieldWithDefault(msg, 5, 0), + shell: jspb.Message.getFieldWithDefault(msg, 6, ""), + builtinExtensionsDir: jspb.Message.getFieldWithDefault(msg, 7, "") }; if (includeInstance) { @@ -1759,78 +737,69 @@ proto.WorkingInitMessage.deserializeBinaryFromReader = function(msg, reader) { }; -/** - * Class method variant: serializes the given message to binary data - * (in protobuf wire format), writing to the given BinaryWriter. - * @param {!proto.WorkingInitMessage} message - * @param {!jspb.BinaryWriter} writer - */ -proto.WorkingInitMessage.serializeBinaryToWriter = function(message, writer) { - message.serializeBinaryToWriter(writer); -}; - - /** * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ proto.WorkingInitMessage.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - this.serializeBinaryToWriter(writer); + proto.WorkingInitMessage.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; /** - * Serializes the message to binary data (in protobuf wire format), - * writing to the given BinaryWriter. + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.WorkingInitMessage} message * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.WorkingInitMessage.prototype.serializeBinaryToWriter = function (writer) { +proto.WorkingInitMessage.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = this.getHomeDirectory(); + f = message.getHomeDirectory(); if (f.length > 0) { writer.writeString( 1, f ); } - f = this.getTmpDirectory(); + f = message.getTmpDirectory(); if (f.length > 0) { writer.writeString( 2, f ); } - f = this.getDataDirectory(); + f = message.getDataDirectory(); if (f.length > 0) { writer.writeString( 3, f ); } - f = this.getWorkingDirectory(); + f = message.getWorkingDirectory(); if (f.length > 0) { writer.writeString( 4, f ); } - f = this.getOperatingSystem(); + f = message.getOperatingSystem(); if (f !== 0.0) { writer.writeEnum( 5, f ); } - f = this.getShell(); + f = message.getShell(); if (f.length > 0) { writer.writeString( 6, f ); } - f = this.getBuiltinExtensionsDir(); + f = message.getBuiltinExtensionsDir(); if (f.length > 0) { writer.writeString( 7, @@ -1840,120 +809,6 @@ proto.WorkingInitMessage.prototype.serializeBinaryToWriter = function (writer) { }; -/** - * Creates a deep clone of this proto. No data is shared with the original. - * @return {!proto.WorkingInitMessage} The clone. - */ -proto.WorkingInitMessage.prototype.cloneMessage = function() { - return /** @type {!proto.WorkingInitMessage} */ (jspb.Message.cloneMessage(this)); -}; - - -/** - * optional string home_directory = 1; - * @return {string} - */ -proto.WorkingInitMessage.prototype.getHomeDirectory = function() { - return /** @type {string} */ (jspb.Message.getFieldProto3(this, 1, "")); -}; - - -/** @param {string} value */ -proto.WorkingInitMessage.prototype.setHomeDirectory = function(value) { - jspb.Message.setField(this, 1, value); -}; - - -/** - * optional string tmp_directory = 2; - * @return {string} - */ -proto.WorkingInitMessage.prototype.getTmpDirectory = function() { - return /** @type {string} */ (jspb.Message.getFieldProto3(this, 2, "")); -}; - - -/** @param {string} value */ -proto.WorkingInitMessage.prototype.setTmpDirectory = function(value) { - jspb.Message.setField(this, 2, value); -}; - - -/** - * optional string data_directory = 3; - * @return {string} - */ -proto.WorkingInitMessage.prototype.getDataDirectory = function() { - return /** @type {string} */ (jspb.Message.getFieldProto3(this, 3, "")); -}; - - -/** @param {string} value */ -proto.WorkingInitMessage.prototype.setDataDirectory = function(value) { - jspb.Message.setField(this, 3, value); -}; - - -/** - * optional string working_directory = 4; - * @return {string} - */ -proto.WorkingInitMessage.prototype.getWorkingDirectory = function() { - return /** @type {string} */ (jspb.Message.getFieldProto3(this, 4, "")); -}; - - -/** @param {string} value */ -proto.WorkingInitMessage.prototype.setWorkingDirectory = function(value) { - jspb.Message.setField(this, 4, value); -}; - - -/** - * optional OperatingSystem operating_system = 5; - * @return {!proto.WorkingInitMessage.OperatingSystem} - */ -proto.WorkingInitMessage.prototype.getOperatingSystem = function() { - return /** @type {!proto.WorkingInitMessage.OperatingSystem} */ (jspb.Message.getFieldProto3(this, 5, 0)); -}; - - -/** @param {!proto.WorkingInitMessage.OperatingSystem} value */ -proto.WorkingInitMessage.prototype.setOperatingSystem = function(value) { - jspb.Message.setField(this, 5, value); -}; - - -/** - * optional string shell = 6; - * @return {string} - */ -proto.WorkingInitMessage.prototype.getShell = function() { - return /** @type {string} */ (jspb.Message.getFieldProto3(this, 6, "")); -}; - - -/** @param {string} value */ -proto.WorkingInitMessage.prototype.setShell = function(value) { - jspb.Message.setField(this, 6, value); -}; - - -/** - * optional string builtin_extensions_dir = 7; - * @return {string} - */ -proto.WorkingInitMessage.prototype.getBuiltinExtensionsDir = function() { - return /** @type {string} */ (jspb.Message.getFieldProto3(this, 7, "")); -}; - - -/** @param {string} value */ -proto.WorkingInitMessage.prototype.setBuiltinExtensionsDir = function(value) { - jspb.Message.setField(this, 7, value); -}; - - /** * @enum {number} */ @@ -1963,4 +818,109 @@ proto.WorkingInitMessage.OperatingSystem = { MAC: 2 }; +/** + * optional string home_directory = 1; + * @return {string} + */ +proto.WorkingInitMessage.prototype.getHomeDirectory = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** @param {string} value */ +proto.WorkingInitMessage.prototype.setHomeDirectory = function(value) { + jspb.Message.setProto3StringField(this, 1, value); +}; + + +/** + * optional string tmp_directory = 2; + * @return {string} + */ +proto.WorkingInitMessage.prototype.getTmpDirectory = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +}; + + +/** @param {string} value */ +proto.WorkingInitMessage.prototype.setTmpDirectory = function(value) { + jspb.Message.setProto3StringField(this, 2, value); +}; + + +/** + * optional string data_directory = 3; + * @return {string} + */ +proto.WorkingInitMessage.prototype.getDataDirectory = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, "")); +}; + + +/** @param {string} value */ +proto.WorkingInitMessage.prototype.setDataDirectory = function(value) { + jspb.Message.setProto3StringField(this, 3, value); +}; + + +/** + * optional string working_directory = 4; + * @return {string} + */ +proto.WorkingInitMessage.prototype.getWorkingDirectory = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 4, "")); +}; + + +/** @param {string} value */ +proto.WorkingInitMessage.prototype.setWorkingDirectory = function(value) { + jspb.Message.setProto3StringField(this, 4, value); +}; + + +/** + * optional OperatingSystem operating_system = 5; + * @return {!proto.WorkingInitMessage.OperatingSystem} + */ +proto.WorkingInitMessage.prototype.getOperatingSystem = function() { + return /** @type {!proto.WorkingInitMessage.OperatingSystem} */ (jspb.Message.getFieldWithDefault(this, 5, 0)); +}; + + +/** @param {!proto.WorkingInitMessage.OperatingSystem} value */ +proto.WorkingInitMessage.prototype.setOperatingSystem = function(value) { + jspb.Message.setProto3EnumField(this, 5, value); +}; + + +/** + * optional string shell = 6; + * @return {string} + */ +proto.WorkingInitMessage.prototype.getShell = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 6, "")); +}; + + +/** @param {string} value */ +proto.WorkingInitMessage.prototype.setShell = function(value) { + jspb.Message.setProto3StringField(this, 6, value); +}; + + +/** + * optional string builtin_extensions_dir = 7; + * @return {string} + */ +proto.WorkingInitMessage.prototype.getBuiltinExtensionsDir = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 7, "")); +}; + + +/** @param {string} value */ +proto.WorkingInitMessage.prototype.setBuiltinExtensionsDir = function(value) { + jspb.Message.setProto3StringField(this, 7, value); +}; + + goog.object.extend(exports, proto); diff --git a/packages/protocol/src/proto/command.proto b/packages/protocol/src/proto/command.proto deleted file mode 100644 index 350a67742..000000000 --- a/packages/protocol/src/proto/command.proto +++ /dev/null @@ -1,143 +0,0 @@ -syntax = "proto3"; - -// Executes a command. -// Ensure the id field is unique for each new session. If a client reuses the id of an existing -// session, the connection will be closed. -// If env is provided, the environment variables will be set. -// If tty_dimensions is included, we will spawn a tty for the command using the given dimensions. -message NewSessionMessage { - uint64 id = 1; - string command = 2; - repeated string args = 3; - map env = 4; - string cwd = 5; - TTYDimensions tty_dimensions = 6; - bool is_fork = 7; - - // Janky, but required for having custom handling of the bootstrap fork - bool is_bootstrap_fork = 8; -} - -// Sent when starting a session failed. -message NewSessionFailureMessage { - uint64 id = 1; - enum Reason { - Prohibited = 0; - ResourceShortage = 1; - } - Reason reason = 2; - string message = 3; -} - -// Sent when a session has completed -message SessionDoneMessage { - uint64 id = 1; - int64 exit_status = 2; -} - -// Identifies a session with a PID and a title. -// Can be sent multiple times when title changes. -message IdentifySessionMessage { - uint64 id = 1; - uint64 pid = 2; - string title = 3; -} - -// Writes data to a session. -message WriteToSessionMessage { - uint64 id = 1; - bytes data = 2; - enum Source { - Stdin = 0; - Ipc = 1; - } - Source source = 3; -} - -// Resizes the TTY of the session identified by the id. -// The connection will be closed if a TTY was not requested when the session was created. -message ResizeSessionTTYMessage { - uint64 id = 1; - TTYDimensions tty_dimensions = 2; -} - -// CloseSessionInputMessage closes the stdin of the session by the ID. -message CloseSessionInputMessage { - uint64 id = 1; -} - -message ShutdownSessionMessage { - uint64 id = 1; - string signal = 2; -} - -// SessionOutputMessage carries data read from the stdout or stderr of the session identified by the id. -message SessionOutputMessage { - uint64 id = 1; - enum Source { - Stdout = 0; - Stderr = 1; - Ipc = 2; - } - Source source = 2; - bytes data = 3; -} - -message TTYDimensions { - uint32 height = 1; - uint32 width = 2; -} - -// Initializes a new connection to a port or path -message NewConnectionMessage { - uint64 id = 1; - uint64 port = 2; - string path = 3; -} - -// Sent when a connection has successfully established -message ConnectionEstablishedMessage { - uint64 id = 1; -} - -// Sent when a connection fails -message NewConnectionFailureMessage { - uint64 id = 1; - string message = 2; -} - -// Sent for connection output -message ConnectionOutputMessage { - uint64 id = 1; - bytes data = 2; -} - -// Sent to close a connection -message ConnectionCloseMessage { - uint64 id = 1; -} - -message NewServerMessage { - uint64 id = 1; - uint64 port = 2; - string path = 3; -} - -message NewServerFailureMessage { - uint64 id = 1; - string message = 2; -} - -message ServerEstablishedMessage { - uint64 id = 1; -} - -message ServerCloseMessage { - uint64 id = 1; - string reason = 2; -} - -message ServerConnectionEstablishedMessage { - uint64 server_id = 1; - uint64 connection_id = 2; -} \ No newline at end of file diff --git a/packages/protocol/src/proto/command_pb.d.ts b/packages/protocol/src/proto/command_pb.d.ts deleted file mode 100644 index f0b65ee48..000000000 --- a/packages/protocol/src/proto/command_pb.d.ts +++ /dev/null @@ -1,544 +0,0 @@ -// package: -// file: command.proto - -import * as jspb from "google-protobuf"; - -export class NewSessionMessage extends jspb.Message { - getId(): number; - setId(value: number): void; - - getCommand(): string; - setCommand(value: string): void; - - clearArgsList(): void; - getArgsList(): Array; - setArgsList(value: Array): void; - addArgs(value: string, index?: number): string; - - getEnvMap(): jspb.Map; - clearEnvMap(): void; - getCwd(): string; - setCwd(value: string): void; - - hasTtyDimensions(): boolean; - clearTtyDimensions(): void; - getTtyDimensions(): TTYDimensions | undefined; - setTtyDimensions(value?: TTYDimensions): void; - - getIsFork(): boolean; - setIsFork(value: boolean): void; - - getIsBootstrapFork(): boolean; - setIsBootstrapFork(value: boolean): void; - - serializeBinary(): Uint8Array; - toObject(includeInstance?: boolean): NewSessionMessage.AsObject; - static toObject(includeInstance: boolean, msg: NewSessionMessage): NewSessionMessage.AsObject; - static extensions: {[key: number]: jspb.ExtensionFieldInfo}; - static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo}; - static serializeBinaryToWriter(message: NewSessionMessage, writer: jspb.BinaryWriter): void; - static deserializeBinary(bytes: Uint8Array): NewSessionMessage; - static deserializeBinaryFromReader(message: NewSessionMessage, reader: jspb.BinaryReader): NewSessionMessage; -} - -export namespace NewSessionMessage { - export type AsObject = { - id: number, - command: string, - argsList: Array, - envMap: Array<[string, string]>, - cwd: string, - ttyDimensions?: TTYDimensions.AsObject, - isFork: boolean, - isBootstrapFork: boolean, - } -} - -export class NewSessionFailureMessage extends jspb.Message { - getId(): number; - setId(value: number): void; - - getReason(): NewSessionFailureMessage.Reason; - setReason(value: NewSessionFailureMessage.Reason): void; - - getMessage(): string; - setMessage(value: string): void; - - serializeBinary(): Uint8Array; - toObject(includeInstance?: boolean): NewSessionFailureMessage.AsObject; - static toObject(includeInstance: boolean, msg: NewSessionFailureMessage): NewSessionFailureMessage.AsObject; - static extensions: {[key: number]: jspb.ExtensionFieldInfo}; - static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo}; - static serializeBinaryToWriter(message: NewSessionFailureMessage, writer: jspb.BinaryWriter): void; - static deserializeBinary(bytes: Uint8Array): NewSessionFailureMessage; - static deserializeBinaryFromReader(message: NewSessionFailureMessage, reader: jspb.BinaryReader): NewSessionFailureMessage; -} - -export namespace NewSessionFailureMessage { - export type AsObject = { - id: number, - reason: NewSessionFailureMessage.Reason, - message: string, - } - - export enum Reason { - PROHIBITED = 0, - RESOURCESHORTAGE = 1, - } -} - -export class SessionDoneMessage extends jspb.Message { - getId(): number; - setId(value: number): void; - - getExitStatus(): number; - setExitStatus(value: number): void; - - serializeBinary(): Uint8Array; - toObject(includeInstance?: boolean): SessionDoneMessage.AsObject; - static toObject(includeInstance: boolean, msg: SessionDoneMessage): SessionDoneMessage.AsObject; - static extensions: {[key: number]: jspb.ExtensionFieldInfo}; - static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo}; - static serializeBinaryToWriter(message: SessionDoneMessage, writer: jspb.BinaryWriter): void; - static deserializeBinary(bytes: Uint8Array): SessionDoneMessage; - static deserializeBinaryFromReader(message: SessionDoneMessage, reader: jspb.BinaryReader): SessionDoneMessage; -} - -export namespace SessionDoneMessage { - export type AsObject = { - id: number, - exitStatus: number, - } -} - -export class IdentifySessionMessage extends jspb.Message { - getId(): number; - setId(value: number): void; - - getPid(): number; - setPid(value: number): void; - - getTitle(): string; - setTitle(value: string): void; - - serializeBinary(): Uint8Array; - toObject(includeInstance?: boolean): IdentifySessionMessage.AsObject; - static toObject(includeInstance: boolean, msg: IdentifySessionMessage): IdentifySessionMessage.AsObject; - static extensions: {[key: number]: jspb.ExtensionFieldInfo}; - static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo}; - static serializeBinaryToWriter(message: IdentifySessionMessage, writer: jspb.BinaryWriter): void; - static deserializeBinary(bytes: Uint8Array): IdentifySessionMessage; - static deserializeBinaryFromReader(message: IdentifySessionMessage, reader: jspb.BinaryReader): IdentifySessionMessage; -} - -export namespace IdentifySessionMessage { - export type AsObject = { - id: number, - pid: number, - title: string, - } -} - -export class WriteToSessionMessage extends jspb.Message { - getId(): number; - setId(value: number): void; - - getData(): Uint8Array | string; - getData_asU8(): Uint8Array; - getData_asB64(): string; - setData(value: Uint8Array | string): void; - - getSource(): WriteToSessionMessage.Source; - setSource(value: WriteToSessionMessage.Source): void; - - serializeBinary(): Uint8Array; - toObject(includeInstance?: boolean): WriteToSessionMessage.AsObject; - static toObject(includeInstance: boolean, msg: WriteToSessionMessage): WriteToSessionMessage.AsObject; - static extensions: {[key: number]: jspb.ExtensionFieldInfo}; - static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo}; - static serializeBinaryToWriter(message: WriteToSessionMessage, writer: jspb.BinaryWriter): void; - static deserializeBinary(bytes: Uint8Array): WriteToSessionMessage; - static deserializeBinaryFromReader(message: WriteToSessionMessage, reader: jspb.BinaryReader): WriteToSessionMessage; -} - -export namespace WriteToSessionMessage { - export type AsObject = { - id: number, - data: Uint8Array | string, - source: WriteToSessionMessage.Source, - } - - export enum Source { - STDIN = 0, - IPC = 1, - } -} - -export class ResizeSessionTTYMessage extends jspb.Message { - getId(): number; - setId(value: number): void; - - hasTtyDimensions(): boolean; - clearTtyDimensions(): void; - getTtyDimensions(): TTYDimensions | undefined; - setTtyDimensions(value?: TTYDimensions): void; - - serializeBinary(): Uint8Array; - toObject(includeInstance?: boolean): ResizeSessionTTYMessage.AsObject; - static toObject(includeInstance: boolean, msg: ResizeSessionTTYMessage): ResizeSessionTTYMessage.AsObject; - static extensions: {[key: number]: jspb.ExtensionFieldInfo}; - static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo}; - static serializeBinaryToWriter(message: ResizeSessionTTYMessage, writer: jspb.BinaryWriter): void; - static deserializeBinary(bytes: Uint8Array): ResizeSessionTTYMessage; - static deserializeBinaryFromReader(message: ResizeSessionTTYMessage, reader: jspb.BinaryReader): ResizeSessionTTYMessage; -} - -export namespace ResizeSessionTTYMessage { - export type AsObject = { - id: number, - ttyDimensions?: TTYDimensions.AsObject, - } -} - -export class CloseSessionInputMessage extends jspb.Message { - getId(): number; - setId(value: number): void; - - serializeBinary(): Uint8Array; - toObject(includeInstance?: boolean): CloseSessionInputMessage.AsObject; - static toObject(includeInstance: boolean, msg: CloseSessionInputMessage): CloseSessionInputMessage.AsObject; - static extensions: {[key: number]: jspb.ExtensionFieldInfo}; - static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo}; - static serializeBinaryToWriter(message: CloseSessionInputMessage, writer: jspb.BinaryWriter): void; - static deserializeBinary(bytes: Uint8Array): CloseSessionInputMessage; - static deserializeBinaryFromReader(message: CloseSessionInputMessage, reader: jspb.BinaryReader): CloseSessionInputMessage; -} - -export namespace CloseSessionInputMessage { - export type AsObject = { - id: number, - } -} - -export class ShutdownSessionMessage extends jspb.Message { - getId(): number; - setId(value: number): void; - - getSignal(): string; - setSignal(value: string): void; - - serializeBinary(): Uint8Array; - toObject(includeInstance?: boolean): ShutdownSessionMessage.AsObject; - static toObject(includeInstance: boolean, msg: ShutdownSessionMessage): ShutdownSessionMessage.AsObject; - static extensions: {[key: number]: jspb.ExtensionFieldInfo}; - static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo}; - static serializeBinaryToWriter(message: ShutdownSessionMessage, writer: jspb.BinaryWriter): void; - static deserializeBinary(bytes: Uint8Array): ShutdownSessionMessage; - static deserializeBinaryFromReader(message: ShutdownSessionMessage, reader: jspb.BinaryReader): ShutdownSessionMessage; -} - -export namespace ShutdownSessionMessage { - export type AsObject = { - id: number, - signal: string, - } -} - -export class SessionOutputMessage extends jspb.Message { - getId(): number; - setId(value: number): void; - - getSource(): SessionOutputMessage.Source; - setSource(value: SessionOutputMessage.Source): void; - - getData(): Uint8Array | string; - getData_asU8(): Uint8Array; - getData_asB64(): string; - setData(value: Uint8Array | string): void; - - serializeBinary(): Uint8Array; - toObject(includeInstance?: boolean): SessionOutputMessage.AsObject; - static toObject(includeInstance: boolean, msg: SessionOutputMessage): SessionOutputMessage.AsObject; - static extensions: {[key: number]: jspb.ExtensionFieldInfo}; - static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo}; - static serializeBinaryToWriter(message: SessionOutputMessage, writer: jspb.BinaryWriter): void; - static deserializeBinary(bytes: Uint8Array): SessionOutputMessage; - static deserializeBinaryFromReader(message: SessionOutputMessage, reader: jspb.BinaryReader): SessionOutputMessage; -} - -export namespace SessionOutputMessage { - export type AsObject = { - id: number, - source: SessionOutputMessage.Source, - data: Uint8Array | string, - } - - export enum Source { - STDOUT = 0, - STDERR = 1, - IPC = 2, - } -} - -export class TTYDimensions extends jspb.Message { - getHeight(): number; - setHeight(value: number): void; - - getWidth(): number; - setWidth(value: number): void; - - serializeBinary(): Uint8Array; - toObject(includeInstance?: boolean): TTYDimensions.AsObject; - static toObject(includeInstance: boolean, msg: TTYDimensions): TTYDimensions.AsObject; - static extensions: {[key: number]: jspb.ExtensionFieldInfo}; - static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo}; - static serializeBinaryToWriter(message: TTYDimensions, writer: jspb.BinaryWriter): void; - static deserializeBinary(bytes: Uint8Array): TTYDimensions; - static deserializeBinaryFromReader(message: TTYDimensions, reader: jspb.BinaryReader): TTYDimensions; -} - -export namespace TTYDimensions { - export type AsObject = { - height: number, - width: number, - } -} - -export class NewConnectionMessage extends jspb.Message { - getId(): number; - setId(value: number): void; - - getPort(): number; - setPort(value: number): void; - - getPath(): string; - setPath(value: string): void; - - serializeBinary(): Uint8Array; - toObject(includeInstance?: boolean): NewConnectionMessage.AsObject; - static toObject(includeInstance: boolean, msg: NewConnectionMessage): NewConnectionMessage.AsObject; - static extensions: {[key: number]: jspb.ExtensionFieldInfo}; - static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo}; - static serializeBinaryToWriter(message: NewConnectionMessage, writer: jspb.BinaryWriter): void; - static deserializeBinary(bytes: Uint8Array): NewConnectionMessage; - static deserializeBinaryFromReader(message: NewConnectionMessage, reader: jspb.BinaryReader): NewConnectionMessage; -} - -export namespace NewConnectionMessage { - export type AsObject = { - id: number, - port: number, - path: string, - } -} - -export class ConnectionEstablishedMessage extends jspb.Message { - getId(): number; - setId(value: number): void; - - serializeBinary(): Uint8Array; - toObject(includeInstance?: boolean): ConnectionEstablishedMessage.AsObject; - static toObject(includeInstance: boolean, msg: ConnectionEstablishedMessage): ConnectionEstablishedMessage.AsObject; - static extensions: {[key: number]: jspb.ExtensionFieldInfo}; - static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo}; - static serializeBinaryToWriter(message: ConnectionEstablishedMessage, writer: jspb.BinaryWriter): void; - static deserializeBinary(bytes: Uint8Array): ConnectionEstablishedMessage; - static deserializeBinaryFromReader(message: ConnectionEstablishedMessage, reader: jspb.BinaryReader): ConnectionEstablishedMessage; -} - -export namespace ConnectionEstablishedMessage { - export type AsObject = { - id: number, - } -} - -export class NewConnectionFailureMessage extends jspb.Message { - getId(): number; - setId(value: number): void; - - getMessage(): string; - setMessage(value: string): void; - - serializeBinary(): Uint8Array; - toObject(includeInstance?: boolean): NewConnectionFailureMessage.AsObject; - static toObject(includeInstance: boolean, msg: NewConnectionFailureMessage): NewConnectionFailureMessage.AsObject; - static extensions: {[key: number]: jspb.ExtensionFieldInfo}; - static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo}; - static serializeBinaryToWriter(message: NewConnectionFailureMessage, writer: jspb.BinaryWriter): void; - static deserializeBinary(bytes: Uint8Array): NewConnectionFailureMessage; - static deserializeBinaryFromReader(message: NewConnectionFailureMessage, reader: jspb.BinaryReader): NewConnectionFailureMessage; -} - -export namespace NewConnectionFailureMessage { - export type AsObject = { - id: number, - message: string, - } -} - -export class ConnectionOutputMessage extends jspb.Message { - getId(): number; - setId(value: number): void; - - getData(): Uint8Array | string; - getData_asU8(): Uint8Array; - getData_asB64(): string; - setData(value: Uint8Array | string): void; - - serializeBinary(): Uint8Array; - toObject(includeInstance?: boolean): ConnectionOutputMessage.AsObject; - static toObject(includeInstance: boolean, msg: ConnectionOutputMessage): ConnectionOutputMessage.AsObject; - static extensions: {[key: number]: jspb.ExtensionFieldInfo}; - static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo}; - static serializeBinaryToWriter(message: ConnectionOutputMessage, writer: jspb.BinaryWriter): void; - static deserializeBinary(bytes: Uint8Array): ConnectionOutputMessage; - static deserializeBinaryFromReader(message: ConnectionOutputMessage, reader: jspb.BinaryReader): ConnectionOutputMessage; -} - -export namespace ConnectionOutputMessage { - export type AsObject = { - id: number, - data: Uint8Array | string, - } -} - -export class ConnectionCloseMessage extends jspb.Message { - getId(): number; - setId(value: number): void; - - serializeBinary(): Uint8Array; - toObject(includeInstance?: boolean): ConnectionCloseMessage.AsObject; - static toObject(includeInstance: boolean, msg: ConnectionCloseMessage): ConnectionCloseMessage.AsObject; - static extensions: {[key: number]: jspb.ExtensionFieldInfo}; - static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo}; - static serializeBinaryToWriter(message: ConnectionCloseMessage, writer: jspb.BinaryWriter): void; - static deserializeBinary(bytes: Uint8Array): ConnectionCloseMessage; - static deserializeBinaryFromReader(message: ConnectionCloseMessage, reader: jspb.BinaryReader): ConnectionCloseMessage; -} - -export namespace ConnectionCloseMessage { - export type AsObject = { - id: number, - } -} - -export class NewServerMessage extends jspb.Message { - getId(): number; - setId(value: number): void; - - getPort(): number; - setPort(value: number): void; - - getPath(): string; - setPath(value: string): void; - - serializeBinary(): Uint8Array; - toObject(includeInstance?: boolean): NewServerMessage.AsObject; - static toObject(includeInstance: boolean, msg: NewServerMessage): NewServerMessage.AsObject; - static extensions: {[key: number]: jspb.ExtensionFieldInfo}; - static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo}; - static serializeBinaryToWriter(message: NewServerMessage, writer: jspb.BinaryWriter): void; - static deserializeBinary(bytes: Uint8Array): NewServerMessage; - static deserializeBinaryFromReader(message: NewServerMessage, reader: jspb.BinaryReader): NewServerMessage; -} - -export namespace NewServerMessage { - export type AsObject = { - id: number, - port: number, - path: string, - } -} - -export class NewServerFailureMessage extends jspb.Message { - getId(): number; - setId(value: number): void; - - getMessage(): string; - setMessage(value: string): void; - - serializeBinary(): Uint8Array; - toObject(includeInstance?: boolean): NewServerFailureMessage.AsObject; - static toObject(includeInstance: boolean, msg: NewServerFailureMessage): NewServerFailureMessage.AsObject; - static extensions: {[key: number]: jspb.ExtensionFieldInfo}; - static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo}; - static serializeBinaryToWriter(message: NewServerFailureMessage, writer: jspb.BinaryWriter): void; - static deserializeBinary(bytes: Uint8Array): NewServerFailureMessage; - static deserializeBinaryFromReader(message: NewServerFailureMessage, reader: jspb.BinaryReader): NewServerFailureMessage; -} - -export namespace NewServerFailureMessage { - export type AsObject = { - id: number, - message: string, - } -} - -export class ServerEstablishedMessage extends jspb.Message { - getId(): number; - setId(value: number): void; - - serializeBinary(): Uint8Array; - toObject(includeInstance?: boolean): ServerEstablishedMessage.AsObject; - static toObject(includeInstance: boolean, msg: ServerEstablishedMessage): ServerEstablishedMessage.AsObject; - static extensions: {[key: number]: jspb.ExtensionFieldInfo}; - static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo}; - static serializeBinaryToWriter(message: ServerEstablishedMessage, writer: jspb.BinaryWriter): void; - static deserializeBinary(bytes: Uint8Array): ServerEstablishedMessage; - static deserializeBinaryFromReader(message: ServerEstablishedMessage, reader: jspb.BinaryReader): ServerEstablishedMessage; -} - -export namespace ServerEstablishedMessage { - export type AsObject = { - id: number, - } -} - -export class ServerCloseMessage extends jspb.Message { - getId(): number; - setId(value: number): void; - - getReason(): string; - setReason(value: string): void; - - serializeBinary(): Uint8Array; - toObject(includeInstance?: boolean): ServerCloseMessage.AsObject; - static toObject(includeInstance: boolean, msg: ServerCloseMessage): ServerCloseMessage.AsObject; - static extensions: {[key: number]: jspb.ExtensionFieldInfo}; - static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo}; - static serializeBinaryToWriter(message: ServerCloseMessage, writer: jspb.BinaryWriter): void; - static deserializeBinary(bytes: Uint8Array): ServerCloseMessage; - static deserializeBinaryFromReader(message: ServerCloseMessage, reader: jspb.BinaryReader): ServerCloseMessage; -} - -export namespace ServerCloseMessage { - export type AsObject = { - id: number, - reason: string, - } -} - -export class ServerConnectionEstablishedMessage extends jspb.Message { - getServerId(): number; - setServerId(value: number): void; - - getConnectionId(): number; - setConnectionId(value: number): void; - - serializeBinary(): Uint8Array; - toObject(includeInstance?: boolean): ServerConnectionEstablishedMessage.AsObject; - static toObject(includeInstance: boolean, msg: ServerConnectionEstablishedMessage): ServerConnectionEstablishedMessage.AsObject; - static extensions: {[key: number]: jspb.ExtensionFieldInfo}; - static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo}; - static serializeBinaryToWriter(message: ServerConnectionEstablishedMessage, writer: jspb.BinaryWriter): void; - static deserializeBinary(bytes: Uint8Array): ServerConnectionEstablishedMessage; - static deserializeBinaryFromReader(message: ServerConnectionEstablishedMessage, reader: jspb.BinaryReader): ServerConnectionEstablishedMessage; -} - -export namespace ServerConnectionEstablishedMessage { - export type AsObject = { - serverId: number, - connectionId: number, - } -} - diff --git a/packages/protocol/src/proto/command_pb.js b/packages/protocol/src/proto/command_pb.js deleted file mode 100644 index 5c3bcabda..000000000 --- a/packages/protocol/src/proto/command_pb.js +++ /dev/null @@ -1,4118 +0,0 @@ -/** - * @fileoverview - * @enhanceable - * @public - */ -// GENERATED CODE -- DO NOT EDIT! - -var jspb = require('google-protobuf'); -var goog = jspb; -var global = Function('return this')(); - -goog.exportSymbol('proto.CloseSessionInputMessage', null, global); -goog.exportSymbol('proto.ConnectionCloseMessage', null, global); -goog.exportSymbol('proto.ConnectionEstablishedMessage', null, global); -goog.exportSymbol('proto.ConnectionOutputMessage', null, global); -goog.exportSymbol('proto.IdentifySessionMessage', null, global); -goog.exportSymbol('proto.NewConnectionFailureMessage', null, global); -goog.exportSymbol('proto.NewConnectionMessage', null, global); -goog.exportSymbol('proto.NewServerFailureMessage', null, global); -goog.exportSymbol('proto.NewServerMessage', null, global); -goog.exportSymbol('proto.NewSessionFailureMessage', null, global); -goog.exportSymbol('proto.NewSessionFailureMessage.Reason', null, global); -goog.exportSymbol('proto.NewSessionMessage', null, global); -goog.exportSymbol('proto.ResizeSessionTTYMessage', null, global); -goog.exportSymbol('proto.ServerCloseMessage', null, global); -goog.exportSymbol('proto.ServerConnectionEstablishedMessage', null, global); -goog.exportSymbol('proto.ServerEstablishedMessage', null, global); -goog.exportSymbol('proto.SessionDoneMessage', null, global); -goog.exportSymbol('proto.SessionOutputMessage', null, global); -goog.exportSymbol('proto.SessionOutputMessage.Source', null, global); -goog.exportSymbol('proto.ShutdownSessionMessage', null, global); -goog.exportSymbol('proto.TTYDimensions', null, global); -goog.exportSymbol('proto.WriteToSessionMessage', null, global); -goog.exportSymbol('proto.WriteToSessionMessage.Source', null, global); - -/** - * Generated by JsPbCodeGenerator. - * @param {Array=} opt_data Optional initial data array, typically from a - * server response, or constructed directly in Javascript. The array is used - * in place and becomes part of the constructed object. It is not cloned. - * If no data is provided, the constructed object will be empty, but still - * valid. - * @extends {jspb.Message} - * @constructor - */ -proto.NewSessionMessage = function(opt_data) { - jspb.Message.initialize(this, opt_data, 0, -1, proto.NewSessionMessage.repeatedFields_, null); -}; -goog.inherits(proto.NewSessionMessage, jspb.Message); -if (goog.DEBUG && !COMPILED) { - proto.NewSessionMessage.displayName = 'proto.NewSessionMessage'; -} -/** - * List of repeated fields within this message type. - * @private {!Array} - * @const - */ -proto.NewSessionMessage.repeatedFields_ = [3]; - - - -if (jspb.Message.GENERATE_TO_OBJECT) { -/** - * Creates an object representation of this proto suitable for use in Soy templates. - * Field names that are reserved in JavaScript and will be renamed to pb_name. - * To access a reserved field use, foo.pb_, eg, foo.pb_default. - * For the list of reserved names please see: - * com.google.apps.jspb.JsClassTemplate.JS_RESERVED_WORDS. - * @param {boolean=} opt_includeInstance Whether to include the JSPB instance - * for transitional soy proto support: http://goto/soy-param-migration - * @return {!Object} - */ -proto.NewSessionMessage.prototype.toObject = function(opt_includeInstance) { - return proto.NewSessionMessage.toObject(opt_includeInstance, this); -}; - - -/** - * Static version of the {@see toObject} method. - * @param {boolean|undefined} includeInstance Whether to include the JSPB - * instance for transitional soy proto support: - * http://goto/soy-param-migration - * @param {!proto.NewSessionMessage} msg The msg instance to transform. - * @return {!Object} - */ -proto.NewSessionMessage.toObject = function(includeInstance, msg) { - var f, obj = { - id: msg.getId(), - command: msg.getCommand(), - argsList: jspb.Message.getField(msg, 3), - envMap: (f = msg.getEnvMap(true)) ? f.toArray() : [], - cwd: msg.getCwd(), - ttyDimensions: (f = msg.getTtyDimensions()) && proto.TTYDimensions.toObject(includeInstance, f), - isFork: msg.getIsFork(), - isBootstrapFork: msg.getIsBootstrapFork() - }; - - if (includeInstance) { - obj.$jspbMessageInstance = msg; - } - return obj; -}; -} - - -/** - * Deserializes binary data (in protobuf wire format). - * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.NewSessionMessage} - */ -proto.NewSessionMessage.deserializeBinary = function(bytes) { - var reader = new jspb.BinaryReader(bytes); - var msg = new proto.NewSessionMessage; - return proto.NewSessionMessage.deserializeBinaryFromReader(msg, reader); -}; - - -/** - * Deserializes binary data (in protobuf wire format) from the - * given reader into the given message object. - * @param {!proto.NewSessionMessage} msg The message object to deserialize into. - * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.NewSessionMessage} - */ -proto.NewSessionMessage.deserializeBinaryFromReader = function(msg, reader) { - while (reader.nextField()) { - if (reader.isEndGroup()) { - break; - } - var field = reader.getFieldNumber(); - switch (field) { - case 1: - var value = /** @type {number} */ (reader.readUint64()); - msg.setId(value); - break; - case 2: - var value = /** @type {string} */ (reader.readString()); - msg.setCommand(value); - break; - case 3: - var value = /** @type {string} */ (reader.readString()); - msg.getArgsList().push(value); - msg.setArgsList(msg.getArgsList()); - break; - case 4: - var value = msg.getEnvMap(); - reader.readMessage(value, function(message, reader) { - jspb.Map.deserializeBinary(message, reader, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readString); - }); - break; - case 5: - var value = /** @type {string} */ (reader.readString()); - msg.setCwd(value); - break; - case 6: - var value = new proto.TTYDimensions; - reader.readMessage(value,proto.TTYDimensions.deserializeBinaryFromReader); - msg.setTtyDimensions(value); - break; - case 7: - var value = /** @type {boolean} */ (reader.readBool()); - msg.setIsFork(value); - break; - case 8: - var value = /** @type {boolean} */ (reader.readBool()); - msg.setIsBootstrapFork(value); - break; - default: - reader.skipField(); - break; - } - } - return msg; -}; - - -/** - * Class method variant: serializes the given message to binary data - * (in protobuf wire format), writing to the given BinaryWriter. - * @param {!proto.NewSessionMessage} message - * @param {!jspb.BinaryWriter} writer - */ -proto.NewSessionMessage.serializeBinaryToWriter = function(message, writer) { - message.serializeBinaryToWriter(writer); -}; - - -/** - * Serializes the message to binary data (in protobuf wire format). - * @return {!Uint8Array} - */ -proto.NewSessionMessage.prototype.serializeBinary = function() { - var writer = new jspb.BinaryWriter(); - this.serializeBinaryToWriter(writer); - return writer.getResultBuffer(); -}; - - -/** - * Serializes the message to binary data (in protobuf wire format), - * writing to the given BinaryWriter. - * @param {!jspb.BinaryWriter} writer - */ -proto.NewSessionMessage.prototype.serializeBinaryToWriter = function (writer) { - var f = undefined; - f = this.getId(); - if (f !== 0) { - writer.writeUint64( - 1, - f - ); - } - f = this.getCommand(); - if (f.length > 0) { - writer.writeString( - 2, - f - ); - } - f = this.getArgsList(); - if (f.length > 0) { - writer.writeRepeatedString( - 3, - f - ); - } - f = this.getEnvMap(true); - if (f && f.getLength() > 0) { - f.serializeBinary(4, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeString); - } - f = this.getCwd(); - if (f.length > 0) { - writer.writeString( - 5, - f - ); - } - f = this.getTtyDimensions(); - if (f != null) { - writer.writeMessage( - 6, - f, - proto.TTYDimensions.serializeBinaryToWriter - ); - } - f = this.getIsFork(); - if (f) { - writer.writeBool( - 7, - f - ); - } - f = this.getIsBootstrapFork(); - if (f) { - writer.writeBool( - 8, - f - ); - } -}; - - -/** - * Creates a deep clone of this proto. No data is shared with the original. - * @return {!proto.NewSessionMessage} The clone. - */ -proto.NewSessionMessage.prototype.cloneMessage = function() { - return /** @type {!proto.NewSessionMessage} */ (jspb.Message.cloneMessage(this)); -}; - - -/** - * optional uint64 id = 1; - * @return {number} - */ -proto.NewSessionMessage.prototype.getId = function() { - return /** @type {number} */ (jspb.Message.getFieldProto3(this, 1, 0)); -}; - - -/** @param {number} value */ -proto.NewSessionMessage.prototype.setId = function(value) { - jspb.Message.setField(this, 1, value); -}; - - -/** - * optional string command = 2; - * @return {string} - */ -proto.NewSessionMessage.prototype.getCommand = function() { - return /** @type {string} */ (jspb.Message.getFieldProto3(this, 2, "")); -}; - - -/** @param {string} value */ -proto.NewSessionMessage.prototype.setCommand = function(value) { - jspb.Message.setField(this, 2, value); -}; - - -/** - * repeated string args = 3; - * If you change this array by adding, removing or replacing elements, or if you - * replace the array itself, then you must call the setter to update it. - * @return {!Array.} - */ -proto.NewSessionMessage.prototype.getArgsList = function() { - return /** @type {!Array.} */ (jspb.Message.getField(this, 3)); -}; - - -/** @param {Array.} value */ -proto.NewSessionMessage.prototype.setArgsList = function(value) { - jspb.Message.setField(this, 3, value || []); -}; - - -proto.NewSessionMessage.prototype.clearArgsList = function() { - jspb.Message.setField(this, 3, []); -}; - - -/** - * map env = 4; - * @param {boolean=} opt_noLazyCreate Do not create the map if - * empty, instead returning `undefined` - * @return {!jspb.Map} - */ -proto.NewSessionMessage.prototype.getEnvMap = function(opt_noLazyCreate) { - return /** @type {!jspb.Map} */ ( - jspb.Message.getMapField(this, 4, opt_noLazyCreate, - null)); -}; - - -/** - * optional string cwd = 5; - * @return {string} - */ -proto.NewSessionMessage.prototype.getCwd = function() { - return /** @type {string} */ (jspb.Message.getFieldProto3(this, 5, "")); -}; - - -/** @param {string} value */ -proto.NewSessionMessage.prototype.setCwd = function(value) { - jspb.Message.setField(this, 5, value); -}; - - -/** - * optional TTYDimensions tty_dimensions = 6; - * @return {proto.TTYDimensions} - */ -proto.NewSessionMessage.prototype.getTtyDimensions = function() { - return /** @type{proto.TTYDimensions} */ ( - jspb.Message.getWrapperField(this, proto.TTYDimensions, 6)); -}; - - -/** @param {proto.TTYDimensions|undefined} value */ -proto.NewSessionMessage.prototype.setTtyDimensions = function(value) { - jspb.Message.setWrapperField(this, 6, value); -}; - - -proto.NewSessionMessage.prototype.clearTtyDimensions = function() { - this.setTtyDimensions(undefined); -}; - - -/** - * Returns whether this field is set. - * @return{!boolean} - */ -proto.NewSessionMessage.prototype.hasTtyDimensions = function() { - return jspb.Message.getField(this, 6) != null; -}; - - -/** - * optional bool is_fork = 7; - * Note that Boolean fields may be set to 0/1 when serialized from a Java server. - * You should avoid comparisons like {@code val === true/false} in those cases. - * @return {boolean} - */ -proto.NewSessionMessage.prototype.getIsFork = function() { - return /** @type {boolean} */ (jspb.Message.getFieldProto3(this, 7, false)); -}; - - -/** @param {boolean} value */ -proto.NewSessionMessage.prototype.setIsFork = function(value) { - jspb.Message.setField(this, 7, value); -}; - - -/** - * optional bool is_bootstrap_fork = 8; - * Note that Boolean fields may be set to 0/1 when serialized from a Java server. - * You should avoid comparisons like {@code val === true/false} in those cases. - * @return {boolean} - */ -proto.NewSessionMessage.prototype.getIsBootstrapFork = function() { - return /** @type {boolean} */ (jspb.Message.getFieldProto3(this, 8, false)); -}; - - -/** @param {boolean} value */ -proto.NewSessionMessage.prototype.setIsBootstrapFork = function(value) { - jspb.Message.setField(this, 8, value); -}; - - - -/** - * Generated by JsPbCodeGenerator. - * @param {Array=} opt_data Optional initial data array, typically from a - * server response, or constructed directly in Javascript. The array is used - * in place and becomes part of the constructed object. It is not cloned. - * If no data is provided, the constructed object will be empty, but still - * valid. - * @extends {jspb.Message} - * @constructor - */ -proto.NewSessionFailureMessage = function(opt_data) { - jspb.Message.initialize(this, opt_data, 0, -1, null, null); -}; -goog.inherits(proto.NewSessionFailureMessage, jspb.Message); -if (goog.DEBUG && !COMPILED) { - proto.NewSessionFailureMessage.displayName = 'proto.NewSessionFailureMessage'; -} - - -if (jspb.Message.GENERATE_TO_OBJECT) { -/** - * Creates an object representation of this proto suitable for use in Soy templates. - * Field names that are reserved in JavaScript and will be renamed to pb_name. - * To access a reserved field use, foo.pb_, eg, foo.pb_default. - * For the list of reserved names please see: - * com.google.apps.jspb.JsClassTemplate.JS_RESERVED_WORDS. - * @param {boolean=} opt_includeInstance Whether to include the JSPB instance - * for transitional soy proto support: http://goto/soy-param-migration - * @return {!Object} - */ -proto.NewSessionFailureMessage.prototype.toObject = function(opt_includeInstance) { - return proto.NewSessionFailureMessage.toObject(opt_includeInstance, this); -}; - - -/** - * Static version of the {@see toObject} method. - * @param {boolean|undefined} includeInstance Whether to include the JSPB - * instance for transitional soy proto support: - * http://goto/soy-param-migration - * @param {!proto.NewSessionFailureMessage} msg The msg instance to transform. - * @return {!Object} - */ -proto.NewSessionFailureMessage.toObject = function(includeInstance, msg) { - var f, obj = { - id: msg.getId(), - reason: msg.getReason(), - message: msg.getMessage() - }; - - if (includeInstance) { - obj.$jspbMessageInstance = msg; - } - return obj; -}; -} - - -/** - * Deserializes binary data (in protobuf wire format). - * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.NewSessionFailureMessage} - */ -proto.NewSessionFailureMessage.deserializeBinary = function(bytes) { - var reader = new jspb.BinaryReader(bytes); - var msg = new proto.NewSessionFailureMessage; - return proto.NewSessionFailureMessage.deserializeBinaryFromReader(msg, reader); -}; - - -/** - * Deserializes binary data (in protobuf wire format) from the - * given reader into the given message object. - * @param {!proto.NewSessionFailureMessage} msg The message object to deserialize into. - * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.NewSessionFailureMessage} - */ -proto.NewSessionFailureMessage.deserializeBinaryFromReader = function(msg, reader) { - while (reader.nextField()) { - if (reader.isEndGroup()) { - break; - } - var field = reader.getFieldNumber(); - switch (field) { - case 1: - var value = /** @type {number} */ (reader.readUint64()); - msg.setId(value); - break; - case 2: - var value = /** @type {!proto.NewSessionFailureMessage.Reason} */ (reader.readEnum()); - msg.setReason(value); - break; - case 3: - var value = /** @type {string} */ (reader.readString()); - msg.setMessage(value); - break; - default: - reader.skipField(); - break; - } - } - return msg; -}; - - -/** - * Class method variant: serializes the given message to binary data - * (in protobuf wire format), writing to the given BinaryWriter. - * @param {!proto.NewSessionFailureMessage} message - * @param {!jspb.BinaryWriter} writer - */ -proto.NewSessionFailureMessage.serializeBinaryToWriter = function(message, writer) { - message.serializeBinaryToWriter(writer); -}; - - -/** - * Serializes the message to binary data (in protobuf wire format). - * @return {!Uint8Array} - */ -proto.NewSessionFailureMessage.prototype.serializeBinary = function() { - var writer = new jspb.BinaryWriter(); - this.serializeBinaryToWriter(writer); - return writer.getResultBuffer(); -}; - - -/** - * Serializes the message to binary data (in protobuf wire format), - * writing to the given BinaryWriter. - * @param {!jspb.BinaryWriter} writer - */ -proto.NewSessionFailureMessage.prototype.serializeBinaryToWriter = function (writer) { - var f = undefined; - f = this.getId(); - if (f !== 0) { - writer.writeUint64( - 1, - f - ); - } - f = this.getReason(); - if (f !== 0.0) { - writer.writeEnum( - 2, - f - ); - } - f = this.getMessage(); - if (f.length > 0) { - writer.writeString( - 3, - f - ); - } -}; - - -/** - * Creates a deep clone of this proto. No data is shared with the original. - * @return {!proto.NewSessionFailureMessage} The clone. - */ -proto.NewSessionFailureMessage.prototype.cloneMessage = function() { - return /** @type {!proto.NewSessionFailureMessage} */ (jspb.Message.cloneMessage(this)); -}; - - -/** - * optional uint64 id = 1; - * @return {number} - */ -proto.NewSessionFailureMessage.prototype.getId = function() { - return /** @type {number} */ (jspb.Message.getFieldProto3(this, 1, 0)); -}; - - -/** @param {number} value */ -proto.NewSessionFailureMessage.prototype.setId = function(value) { - jspb.Message.setField(this, 1, value); -}; - - -/** - * optional Reason reason = 2; - * @return {!proto.NewSessionFailureMessage.Reason} - */ -proto.NewSessionFailureMessage.prototype.getReason = function() { - return /** @type {!proto.NewSessionFailureMessage.Reason} */ (jspb.Message.getFieldProto3(this, 2, 0)); -}; - - -/** @param {!proto.NewSessionFailureMessage.Reason} value */ -proto.NewSessionFailureMessage.prototype.setReason = function(value) { - jspb.Message.setField(this, 2, value); -}; - - -/** - * optional string message = 3; - * @return {string} - */ -proto.NewSessionFailureMessage.prototype.getMessage = function() { - return /** @type {string} */ (jspb.Message.getFieldProto3(this, 3, "")); -}; - - -/** @param {string} value */ -proto.NewSessionFailureMessage.prototype.setMessage = function(value) { - jspb.Message.setField(this, 3, value); -}; - - -/** - * @enum {number} - */ -proto.NewSessionFailureMessage.Reason = { - PROHIBITED: 0, - RESOURCESHORTAGE: 1 -}; - - -/** - * Generated by JsPbCodeGenerator. - * @param {Array=} opt_data Optional initial data array, typically from a - * server response, or constructed directly in Javascript. The array is used - * in place and becomes part of the constructed object. It is not cloned. - * If no data is provided, the constructed object will be empty, but still - * valid. - * @extends {jspb.Message} - * @constructor - */ -proto.SessionDoneMessage = function(opt_data) { - jspb.Message.initialize(this, opt_data, 0, -1, null, null); -}; -goog.inherits(proto.SessionDoneMessage, jspb.Message); -if (goog.DEBUG && !COMPILED) { - proto.SessionDoneMessage.displayName = 'proto.SessionDoneMessage'; -} - - -if (jspb.Message.GENERATE_TO_OBJECT) { -/** - * Creates an object representation of this proto suitable for use in Soy templates. - * Field names that are reserved in JavaScript and will be renamed to pb_name. - * To access a reserved field use, foo.pb_, eg, foo.pb_default. - * For the list of reserved names please see: - * com.google.apps.jspb.JsClassTemplate.JS_RESERVED_WORDS. - * @param {boolean=} opt_includeInstance Whether to include the JSPB instance - * for transitional soy proto support: http://goto/soy-param-migration - * @return {!Object} - */ -proto.SessionDoneMessage.prototype.toObject = function(opt_includeInstance) { - return proto.SessionDoneMessage.toObject(opt_includeInstance, this); -}; - - -/** - * Static version of the {@see toObject} method. - * @param {boolean|undefined} includeInstance Whether to include the JSPB - * instance for transitional soy proto support: - * http://goto/soy-param-migration - * @param {!proto.SessionDoneMessage} msg The msg instance to transform. - * @return {!Object} - */ -proto.SessionDoneMessage.toObject = function(includeInstance, msg) { - var f, obj = { - id: msg.getId(), - exitStatus: msg.getExitStatus() - }; - - if (includeInstance) { - obj.$jspbMessageInstance = msg; - } - return obj; -}; -} - - -/** - * Deserializes binary data (in protobuf wire format). - * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.SessionDoneMessage} - */ -proto.SessionDoneMessage.deserializeBinary = function(bytes) { - var reader = new jspb.BinaryReader(bytes); - var msg = new proto.SessionDoneMessage; - return proto.SessionDoneMessage.deserializeBinaryFromReader(msg, reader); -}; - - -/** - * Deserializes binary data (in protobuf wire format) from the - * given reader into the given message object. - * @param {!proto.SessionDoneMessage} msg The message object to deserialize into. - * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.SessionDoneMessage} - */ -proto.SessionDoneMessage.deserializeBinaryFromReader = function(msg, reader) { - while (reader.nextField()) { - if (reader.isEndGroup()) { - break; - } - var field = reader.getFieldNumber(); - switch (field) { - case 1: - var value = /** @type {number} */ (reader.readUint64()); - msg.setId(value); - break; - case 2: - var value = /** @type {number} */ (reader.readInt64()); - msg.setExitStatus(value); - break; - default: - reader.skipField(); - break; - } - } - return msg; -}; - - -/** - * Class method variant: serializes the given message to binary data - * (in protobuf wire format), writing to the given BinaryWriter. - * @param {!proto.SessionDoneMessage} message - * @param {!jspb.BinaryWriter} writer - */ -proto.SessionDoneMessage.serializeBinaryToWriter = function(message, writer) { - message.serializeBinaryToWriter(writer); -}; - - -/** - * Serializes the message to binary data (in protobuf wire format). - * @return {!Uint8Array} - */ -proto.SessionDoneMessage.prototype.serializeBinary = function() { - var writer = new jspb.BinaryWriter(); - this.serializeBinaryToWriter(writer); - return writer.getResultBuffer(); -}; - - -/** - * Serializes the message to binary data (in protobuf wire format), - * writing to the given BinaryWriter. - * @param {!jspb.BinaryWriter} writer - */ -proto.SessionDoneMessage.prototype.serializeBinaryToWriter = function (writer) { - var f = undefined; - f = this.getId(); - if (f !== 0) { - writer.writeUint64( - 1, - f - ); - } - f = this.getExitStatus(); - if (f !== 0) { - writer.writeInt64( - 2, - f - ); - } -}; - - -/** - * Creates a deep clone of this proto. No data is shared with the original. - * @return {!proto.SessionDoneMessage} The clone. - */ -proto.SessionDoneMessage.prototype.cloneMessage = function() { - return /** @type {!proto.SessionDoneMessage} */ (jspb.Message.cloneMessage(this)); -}; - - -/** - * optional uint64 id = 1; - * @return {number} - */ -proto.SessionDoneMessage.prototype.getId = function() { - return /** @type {number} */ (jspb.Message.getFieldProto3(this, 1, 0)); -}; - - -/** @param {number} value */ -proto.SessionDoneMessage.prototype.setId = function(value) { - jspb.Message.setField(this, 1, value); -}; - - -/** - * optional int64 exit_status = 2; - * @return {number} - */ -proto.SessionDoneMessage.prototype.getExitStatus = function() { - return /** @type {number} */ (jspb.Message.getFieldProto3(this, 2, 0)); -}; - - -/** @param {number} value */ -proto.SessionDoneMessage.prototype.setExitStatus = function(value) { - jspb.Message.setField(this, 2, value); -}; - - - -/** - * Generated by JsPbCodeGenerator. - * @param {Array=} opt_data Optional initial data array, typically from a - * server response, or constructed directly in Javascript. The array is used - * in place and becomes part of the constructed object. It is not cloned. - * If no data is provided, the constructed object will be empty, but still - * valid. - * @extends {jspb.Message} - * @constructor - */ -proto.IdentifySessionMessage = function(opt_data) { - jspb.Message.initialize(this, opt_data, 0, -1, null, null); -}; -goog.inherits(proto.IdentifySessionMessage, jspb.Message); -if (goog.DEBUG && !COMPILED) { - proto.IdentifySessionMessage.displayName = 'proto.IdentifySessionMessage'; -} - - -if (jspb.Message.GENERATE_TO_OBJECT) { -/** - * Creates an object representation of this proto suitable for use in Soy templates. - * Field names that are reserved in JavaScript and will be renamed to pb_name. - * To access a reserved field use, foo.pb_, eg, foo.pb_default. - * For the list of reserved names please see: - * com.google.apps.jspb.JsClassTemplate.JS_RESERVED_WORDS. - * @param {boolean=} opt_includeInstance Whether to include the JSPB instance - * for transitional soy proto support: http://goto/soy-param-migration - * @return {!Object} - */ -proto.IdentifySessionMessage.prototype.toObject = function(opt_includeInstance) { - return proto.IdentifySessionMessage.toObject(opt_includeInstance, this); -}; - - -/** - * Static version of the {@see toObject} method. - * @param {boolean|undefined} includeInstance Whether to include the JSPB - * instance for transitional soy proto support: - * http://goto/soy-param-migration - * @param {!proto.IdentifySessionMessage} msg The msg instance to transform. - * @return {!Object} - */ -proto.IdentifySessionMessage.toObject = function(includeInstance, msg) { - var f, obj = { - id: msg.getId(), - pid: msg.getPid(), - title: msg.getTitle() - }; - - if (includeInstance) { - obj.$jspbMessageInstance = msg; - } - return obj; -}; -} - - -/** - * Deserializes binary data (in protobuf wire format). - * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.IdentifySessionMessage} - */ -proto.IdentifySessionMessage.deserializeBinary = function(bytes) { - var reader = new jspb.BinaryReader(bytes); - var msg = new proto.IdentifySessionMessage; - return proto.IdentifySessionMessage.deserializeBinaryFromReader(msg, reader); -}; - - -/** - * Deserializes binary data (in protobuf wire format) from the - * given reader into the given message object. - * @param {!proto.IdentifySessionMessage} msg The message object to deserialize into. - * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.IdentifySessionMessage} - */ -proto.IdentifySessionMessage.deserializeBinaryFromReader = function(msg, reader) { - while (reader.nextField()) { - if (reader.isEndGroup()) { - break; - } - var field = reader.getFieldNumber(); - switch (field) { - case 1: - var value = /** @type {number} */ (reader.readUint64()); - msg.setId(value); - break; - case 2: - var value = /** @type {number} */ (reader.readUint64()); - msg.setPid(value); - break; - case 3: - var value = /** @type {string} */ (reader.readString()); - msg.setTitle(value); - break; - default: - reader.skipField(); - break; - } - } - return msg; -}; - - -/** - * Class method variant: serializes the given message to binary data - * (in protobuf wire format), writing to the given BinaryWriter. - * @param {!proto.IdentifySessionMessage} message - * @param {!jspb.BinaryWriter} writer - */ -proto.IdentifySessionMessage.serializeBinaryToWriter = function(message, writer) { - message.serializeBinaryToWriter(writer); -}; - - -/** - * Serializes the message to binary data (in protobuf wire format). - * @return {!Uint8Array} - */ -proto.IdentifySessionMessage.prototype.serializeBinary = function() { - var writer = new jspb.BinaryWriter(); - this.serializeBinaryToWriter(writer); - return writer.getResultBuffer(); -}; - - -/** - * Serializes the message to binary data (in protobuf wire format), - * writing to the given BinaryWriter. - * @param {!jspb.BinaryWriter} writer - */ -proto.IdentifySessionMessage.prototype.serializeBinaryToWriter = function (writer) { - var f = undefined; - f = this.getId(); - if (f !== 0) { - writer.writeUint64( - 1, - f - ); - } - f = this.getPid(); - if (f !== 0) { - writer.writeUint64( - 2, - f - ); - } - f = this.getTitle(); - if (f.length > 0) { - writer.writeString( - 3, - f - ); - } -}; - - -/** - * Creates a deep clone of this proto. No data is shared with the original. - * @return {!proto.IdentifySessionMessage} The clone. - */ -proto.IdentifySessionMessage.prototype.cloneMessage = function() { - return /** @type {!proto.IdentifySessionMessage} */ (jspb.Message.cloneMessage(this)); -}; - - -/** - * optional uint64 id = 1; - * @return {number} - */ -proto.IdentifySessionMessage.prototype.getId = function() { - return /** @type {number} */ (jspb.Message.getFieldProto3(this, 1, 0)); -}; - - -/** @param {number} value */ -proto.IdentifySessionMessage.prototype.setId = function(value) { - jspb.Message.setField(this, 1, value); -}; - - -/** - * optional uint64 pid = 2; - * @return {number} - */ -proto.IdentifySessionMessage.prototype.getPid = function() { - return /** @type {number} */ (jspb.Message.getFieldProto3(this, 2, 0)); -}; - - -/** @param {number} value */ -proto.IdentifySessionMessage.prototype.setPid = function(value) { - jspb.Message.setField(this, 2, value); -}; - - -/** - * optional string title = 3; - * @return {string} - */ -proto.IdentifySessionMessage.prototype.getTitle = function() { - return /** @type {string} */ (jspb.Message.getFieldProto3(this, 3, "")); -}; - - -/** @param {string} value */ -proto.IdentifySessionMessage.prototype.setTitle = function(value) { - jspb.Message.setField(this, 3, value); -}; - - - -/** - * Generated by JsPbCodeGenerator. - * @param {Array=} opt_data Optional initial data array, typically from a - * server response, or constructed directly in Javascript. The array is used - * in place and becomes part of the constructed object. It is not cloned. - * If no data is provided, the constructed object will be empty, but still - * valid. - * @extends {jspb.Message} - * @constructor - */ -proto.WriteToSessionMessage = function(opt_data) { - jspb.Message.initialize(this, opt_data, 0, -1, null, null); -}; -goog.inherits(proto.WriteToSessionMessage, jspb.Message); -if (goog.DEBUG && !COMPILED) { - proto.WriteToSessionMessage.displayName = 'proto.WriteToSessionMessage'; -} - - -if (jspb.Message.GENERATE_TO_OBJECT) { -/** - * Creates an object representation of this proto suitable for use in Soy templates. - * Field names that are reserved in JavaScript and will be renamed to pb_name. - * To access a reserved field use, foo.pb_, eg, foo.pb_default. - * For the list of reserved names please see: - * com.google.apps.jspb.JsClassTemplate.JS_RESERVED_WORDS. - * @param {boolean=} opt_includeInstance Whether to include the JSPB instance - * for transitional soy proto support: http://goto/soy-param-migration - * @return {!Object} - */ -proto.WriteToSessionMessage.prototype.toObject = function(opt_includeInstance) { - return proto.WriteToSessionMessage.toObject(opt_includeInstance, this); -}; - - -/** - * Static version of the {@see toObject} method. - * @param {boolean|undefined} includeInstance Whether to include the JSPB - * instance for transitional soy proto support: - * http://goto/soy-param-migration - * @param {!proto.WriteToSessionMessage} msg The msg instance to transform. - * @return {!Object} - */ -proto.WriteToSessionMessage.toObject = function(includeInstance, msg) { - var f, obj = { - id: msg.getId(), - data: msg.getData_asB64(), - source: msg.getSource() - }; - - if (includeInstance) { - obj.$jspbMessageInstance = msg; - } - return obj; -}; -} - - -/** - * Deserializes binary data (in protobuf wire format). - * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.WriteToSessionMessage} - */ -proto.WriteToSessionMessage.deserializeBinary = function(bytes) { - var reader = new jspb.BinaryReader(bytes); - var msg = new proto.WriteToSessionMessage; - return proto.WriteToSessionMessage.deserializeBinaryFromReader(msg, reader); -}; - - -/** - * Deserializes binary data (in protobuf wire format) from the - * given reader into the given message object. - * @param {!proto.WriteToSessionMessage} msg The message object to deserialize into. - * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.WriteToSessionMessage} - */ -proto.WriteToSessionMessage.deserializeBinaryFromReader = function(msg, reader) { - while (reader.nextField()) { - if (reader.isEndGroup()) { - break; - } - var field = reader.getFieldNumber(); - switch (field) { - case 1: - var value = /** @type {number} */ (reader.readUint64()); - msg.setId(value); - break; - case 2: - var value = /** @type {!Uint8Array} */ (reader.readBytes()); - msg.setData(value); - break; - case 3: - var value = /** @type {!proto.WriteToSessionMessage.Source} */ (reader.readEnum()); - msg.setSource(value); - break; - default: - reader.skipField(); - break; - } - } - return msg; -}; - - -/** - * Class method variant: serializes the given message to binary data - * (in protobuf wire format), writing to the given BinaryWriter. - * @param {!proto.WriteToSessionMessage} message - * @param {!jspb.BinaryWriter} writer - */ -proto.WriteToSessionMessage.serializeBinaryToWriter = function(message, writer) { - message.serializeBinaryToWriter(writer); -}; - - -/** - * Serializes the message to binary data (in protobuf wire format). - * @return {!Uint8Array} - */ -proto.WriteToSessionMessage.prototype.serializeBinary = function() { - var writer = new jspb.BinaryWriter(); - this.serializeBinaryToWriter(writer); - return writer.getResultBuffer(); -}; - - -/** - * Serializes the message to binary data (in protobuf wire format), - * writing to the given BinaryWriter. - * @param {!jspb.BinaryWriter} writer - */ -proto.WriteToSessionMessage.prototype.serializeBinaryToWriter = function (writer) { - var f = undefined; - f = this.getId(); - if (f !== 0) { - writer.writeUint64( - 1, - f - ); - } - f = this.getData_asU8(); - if (f.length > 0) { - writer.writeBytes( - 2, - f - ); - } - f = this.getSource(); - if (f !== 0.0) { - writer.writeEnum( - 3, - f - ); - } -}; - - -/** - * Creates a deep clone of this proto. No data is shared with the original. - * @return {!proto.WriteToSessionMessage} The clone. - */ -proto.WriteToSessionMessage.prototype.cloneMessage = function() { - return /** @type {!proto.WriteToSessionMessage} */ (jspb.Message.cloneMessage(this)); -}; - - -/** - * optional uint64 id = 1; - * @return {number} - */ -proto.WriteToSessionMessage.prototype.getId = function() { - return /** @type {number} */ (jspb.Message.getFieldProto3(this, 1, 0)); -}; - - -/** @param {number} value */ -proto.WriteToSessionMessage.prototype.setId = function(value) { - jspb.Message.setField(this, 1, value); -}; - - -/** - * optional bytes data = 2; - * @return {!(string|Uint8Array)} - */ -proto.WriteToSessionMessage.prototype.getData = function() { - return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldProto3(this, 2, "")); -}; - - -/** - * optional bytes data = 2; - * This is a type-conversion wrapper around `getData()` - * @return {string} - */ -proto.WriteToSessionMessage.prototype.getData_asB64 = function() { - return /** @type {string} */ (jspb.Message.bytesAsB64( - this.getData())); -}; - - -/** - * optional bytes data = 2; - * Note that Uint8Array is not supported on all browsers. - * @see http://caniuse.com/Uint8Array - * This is a type-conversion wrapper around `getData()` - * @return {!Uint8Array} - */ -proto.WriteToSessionMessage.prototype.getData_asU8 = function() { - return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( - this.getData())); -}; - - -/** @param {!(string|Uint8Array)} value */ -proto.WriteToSessionMessage.prototype.setData = function(value) { - jspb.Message.setField(this, 2, value); -}; - - -/** - * optional Source source = 3; - * @return {!proto.WriteToSessionMessage.Source} - */ -proto.WriteToSessionMessage.prototype.getSource = function() { - return /** @type {!proto.WriteToSessionMessage.Source} */ (jspb.Message.getFieldProto3(this, 3, 0)); -}; - - -/** @param {!proto.WriteToSessionMessage.Source} value */ -proto.WriteToSessionMessage.prototype.setSource = function(value) { - jspb.Message.setField(this, 3, value); -}; - - -/** - * @enum {number} - */ -proto.WriteToSessionMessage.Source = { - STDIN: 0, - IPC: 1 -}; - - -/** - * Generated by JsPbCodeGenerator. - * @param {Array=} opt_data Optional initial data array, typically from a - * server response, or constructed directly in Javascript. The array is used - * in place and becomes part of the constructed object. It is not cloned. - * If no data is provided, the constructed object will be empty, but still - * valid. - * @extends {jspb.Message} - * @constructor - */ -proto.ResizeSessionTTYMessage = function(opt_data) { - jspb.Message.initialize(this, opt_data, 0, -1, null, null); -}; -goog.inherits(proto.ResizeSessionTTYMessage, jspb.Message); -if (goog.DEBUG && !COMPILED) { - proto.ResizeSessionTTYMessage.displayName = 'proto.ResizeSessionTTYMessage'; -} - - -if (jspb.Message.GENERATE_TO_OBJECT) { -/** - * Creates an object representation of this proto suitable for use in Soy templates. - * Field names that are reserved in JavaScript and will be renamed to pb_name. - * To access a reserved field use, foo.pb_, eg, foo.pb_default. - * For the list of reserved names please see: - * com.google.apps.jspb.JsClassTemplate.JS_RESERVED_WORDS. - * @param {boolean=} opt_includeInstance Whether to include the JSPB instance - * for transitional soy proto support: http://goto/soy-param-migration - * @return {!Object} - */ -proto.ResizeSessionTTYMessage.prototype.toObject = function(opt_includeInstance) { - return proto.ResizeSessionTTYMessage.toObject(opt_includeInstance, this); -}; - - -/** - * Static version of the {@see toObject} method. - * @param {boolean|undefined} includeInstance Whether to include the JSPB - * instance for transitional soy proto support: - * http://goto/soy-param-migration - * @param {!proto.ResizeSessionTTYMessage} msg The msg instance to transform. - * @return {!Object} - */ -proto.ResizeSessionTTYMessage.toObject = function(includeInstance, msg) { - var f, obj = { - id: msg.getId(), - ttyDimensions: (f = msg.getTtyDimensions()) && proto.TTYDimensions.toObject(includeInstance, f) - }; - - if (includeInstance) { - obj.$jspbMessageInstance = msg; - } - return obj; -}; -} - - -/** - * Deserializes binary data (in protobuf wire format). - * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.ResizeSessionTTYMessage} - */ -proto.ResizeSessionTTYMessage.deserializeBinary = function(bytes) { - var reader = new jspb.BinaryReader(bytes); - var msg = new proto.ResizeSessionTTYMessage; - return proto.ResizeSessionTTYMessage.deserializeBinaryFromReader(msg, reader); -}; - - -/** - * Deserializes binary data (in protobuf wire format) from the - * given reader into the given message object. - * @param {!proto.ResizeSessionTTYMessage} msg The message object to deserialize into. - * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.ResizeSessionTTYMessage} - */ -proto.ResizeSessionTTYMessage.deserializeBinaryFromReader = function(msg, reader) { - while (reader.nextField()) { - if (reader.isEndGroup()) { - break; - } - var field = reader.getFieldNumber(); - switch (field) { - case 1: - var value = /** @type {number} */ (reader.readUint64()); - msg.setId(value); - break; - case 2: - var value = new proto.TTYDimensions; - reader.readMessage(value,proto.TTYDimensions.deserializeBinaryFromReader); - msg.setTtyDimensions(value); - break; - default: - reader.skipField(); - break; - } - } - return msg; -}; - - -/** - * Class method variant: serializes the given message to binary data - * (in protobuf wire format), writing to the given BinaryWriter. - * @param {!proto.ResizeSessionTTYMessage} message - * @param {!jspb.BinaryWriter} writer - */ -proto.ResizeSessionTTYMessage.serializeBinaryToWriter = function(message, writer) { - message.serializeBinaryToWriter(writer); -}; - - -/** - * Serializes the message to binary data (in protobuf wire format). - * @return {!Uint8Array} - */ -proto.ResizeSessionTTYMessage.prototype.serializeBinary = function() { - var writer = new jspb.BinaryWriter(); - this.serializeBinaryToWriter(writer); - return writer.getResultBuffer(); -}; - - -/** - * Serializes the message to binary data (in protobuf wire format), - * writing to the given BinaryWriter. - * @param {!jspb.BinaryWriter} writer - */ -proto.ResizeSessionTTYMessage.prototype.serializeBinaryToWriter = function (writer) { - var f = undefined; - f = this.getId(); - if (f !== 0) { - writer.writeUint64( - 1, - f - ); - } - f = this.getTtyDimensions(); - if (f != null) { - writer.writeMessage( - 2, - f, - proto.TTYDimensions.serializeBinaryToWriter - ); - } -}; - - -/** - * Creates a deep clone of this proto. No data is shared with the original. - * @return {!proto.ResizeSessionTTYMessage} The clone. - */ -proto.ResizeSessionTTYMessage.prototype.cloneMessage = function() { - return /** @type {!proto.ResizeSessionTTYMessage} */ (jspb.Message.cloneMessage(this)); -}; - - -/** - * optional uint64 id = 1; - * @return {number} - */ -proto.ResizeSessionTTYMessage.prototype.getId = function() { - return /** @type {number} */ (jspb.Message.getFieldProto3(this, 1, 0)); -}; - - -/** @param {number} value */ -proto.ResizeSessionTTYMessage.prototype.setId = function(value) { - jspb.Message.setField(this, 1, value); -}; - - -/** - * optional TTYDimensions tty_dimensions = 2; - * @return {proto.TTYDimensions} - */ -proto.ResizeSessionTTYMessage.prototype.getTtyDimensions = function() { - return /** @type{proto.TTYDimensions} */ ( - jspb.Message.getWrapperField(this, proto.TTYDimensions, 2)); -}; - - -/** @param {proto.TTYDimensions|undefined} value */ -proto.ResizeSessionTTYMessage.prototype.setTtyDimensions = function(value) { - jspb.Message.setWrapperField(this, 2, value); -}; - - -proto.ResizeSessionTTYMessage.prototype.clearTtyDimensions = function() { - this.setTtyDimensions(undefined); -}; - - -/** - * Returns whether this field is set. - * @return{!boolean} - */ -proto.ResizeSessionTTYMessage.prototype.hasTtyDimensions = function() { - return jspb.Message.getField(this, 2) != null; -}; - - - -/** - * Generated by JsPbCodeGenerator. - * @param {Array=} opt_data Optional initial data array, typically from a - * server response, or constructed directly in Javascript. The array is used - * in place and becomes part of the constructed object. It is not cloned. - * If no data is provided, the constructed object will be empty, but still - * valid. - * @extends {jspb.Message} - * @constructor - */ -proto.CloseSessionInputMessage = function(opt_data) { - jspb.Message.initialize(this, opt_data, 0, -1, null, null); -}; -goog.inherits(proto.CloseSessionInputMessage, jspb.Message); -if (goog.DEBUG && !COMPILED) { - proto.CloseSessionInputMessage.displayName = 'proto.CloseSessionInputMessage'; -} - - -if (jspb.Message.GENERATE_TO_OBJECT) { -/** - * Creates an object representation of this proto suitable for use in Soy templates. - * Field names that are reserved in JavaScript and will be renamed to pb_name. - * To access a reserved field use, foo.pb_, eg, foo.pb_default. - * For the list of reserved names please see: - * com.google.apps.jspb.JsClassTemplate.JS_RESERVED_WORDS. - * @param {boolean=} opt_includeInstance Whether to include the JSPB instance - * for transitional soy proto support: http://goto/soy-param-migration - * @return {!Object} - */ -proto.CloseSessionInputMessage.prototype.toObject = function(opt_includeInstance) { - return proto.CloseSessionInputMessage.toObject(opt_includeInstance, this); -}; - - -/** - * Static version of the {@see toObject} method. - * @param {boolean|undefined} includeInstance Whether to include the JSPB - * instance for transitional soy proto support: - * http://goto/soy-param-migration - * @param {!proto.CloseSessionInputMessage} msg The msg instance to transform. - * @return {!Object} - */ -proto.CloseSessionInputMessage.toObject = function(includeInstance, msg) { - var f, obj = { - id: msg.getId() - }; - - if (includeInstance) { - obj.$jspbMessageInstance = msg; - } - return obj; -}; -} - - -/** - * Deserializes binary data (in protobuf wire format). - * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.CloseSessionInputMessage} - */ -proto.CloseSessionInputMessage.deserializeBinary = function(bytes) { - var reader = new jspb.BinaryReader(bytes); - var msg = new proto.CloseSessionInputMessage; - return proto.CloseSessionInputMessage.deserializeBinaryFromReader(msg, reader); -}; - - -/** - * Deserializes binary data (in protobuf wire format) from the - * given reader into the given message object. - * @param {!proto.CloseSessionInputMessage} msg The message object to deserialize into. - * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.CloseSessionInputMessage} - */ -proto.CloseSessionInputMessage.deserializeBinaryFromReader = function(msg, reader) { - while (reader.nextField()) { - if (reader.isEndGroup()) { - break; - } - var field = reader.getFieldNumber(); - switch (field) { - case 1: - var value = /** @type {number} */ (reader.readUint64()); - msg.setId(value); - break; - default: - reader.skipField(); - break; - } - } - return msg; -}; - - -/** - * Class method variant: serializes the given message to binary data - * (in protobuf wire format), writing to the given BinaryWriter. - * @param {!proto.CloseSessionInputMessage} message - * @param {!jspb.BinaryWriter} writer - */ -proto.CloseSessionInputMessage.serializeBinaryToWriter = function(message, writer) { - message.serializeBinaryToWriter(writer); -}; - - -/** - * Serializes the message to binary data (in protobuf wire format). - * @return {!Uint8Array} - */ -proto.CloseSessionInputMessage.prototype.serializeBinary = function() { - var writer = new jspb.BinaryWriter(); - this.serializeBinaryToWriter(writer); - return writer.getResultBuffer(); -}; - - -/** - * Serializes the message to binary data (in protobuf wire format), - * writing to the given BinaryWriter. - * @param {!jspb.BinaryWriter} writer - */ -proto.CloseSessionInputMessage.prototype.serializeBinaryToWriter = function (writer) { - var f = undefined; - f = this.getId(); - if (f !== 0) { - writer.writeUint64( - 1, - f - ); - } -}; - - -/** - * Creates a deep clone of this proto. No data is shared with the original. - * @return {!proto.CloseSessionInputMessage} The clone. - */ -proto.CloseSessionInputMessage.prototype.cloneMessage = function() { - return /** @type {!proto.CloseSessionInputMessage} */ (jspb.Message.cloneMessage(this)); -}; - - -/** - * optional uint64 id = 1; - * @return {number} - */ -proto.CloseSessionInputMessage.prototype.getId = function() { - return /** @type {number} */ (jspb.Message.getFieldProto3(this, 1, 0)); -}; - - -/** @param {number} value */ -proto.CloseSessionInputMessage.prototype.setId = function(value) { - jspb.Message.setField(this, 1, value); -}; - - - -/** - * Generated by JsPbCodeGenerator. - * @param {Array=} opt_data Optional initial data array, typically from a - * server response, or constructed directly in Javascript. The array is used - * in place and becomes part of the constructed object. It is not cloned. - * If no data is provided, the constructed object will be empty, but still - * valid. - * @extends {jspb.Message} - * @constructor - */ -proto.ShutdownSessionMessage = function(opt_data) { - jspb.Message.initialize(this, opt_data, 0, -1, null, null); -}; -goog.inherits(proto.ShutdownSessionMessage, jspb.Message); -if (goog.DEBUG && !COMPILED) { - proto.ShutdownSessionMessage.displayName = 'proto.ShutdownSessionMessage'; -} - - -if (jspb.Message.GENERATE_TO_OBJECT) { -/** - * Creates an object representation of this proto suitable for use in Soy templates. - * Field names that are reserved in JavaScript and will be renamed to pb_name. - * To access a reserved field use, foo.pb_, eg, foo.pb_default. - * For the list of reserved names please see: - * com.google.apps.jspb.JsClassTemplate.JS_RESERVED_WORDS. - * @param {boolean=} opt_includeInstance Whether to include the JSPB instance - * for transitional soy proto support: http://goto/soy-param-migration - * @return {!Object} - */ -proto.ShutdownSessionMessage.prototype.toObject = function(opt_includeInstance) { - return proto.ShutdownSessionMessage.toObject(opt_includeInstance, this); -}; - - -/** - * Static version of the {@see toObject} method. - * @param {boolean|undefined} includeInstance Whether to include the JSPB - * instance for transitional soy proto support: - * http://goto/soy-param-migration - * @param {!proto.ShutdownSessionMessage} msg The msg instance to transform. - * @return {!Object} - */ -proto.ShutdownSessionMessage.toObject = function(includeInstance, msg) { - var f, obj = { - id: msg.getId(), - signal: msg.getSignal() - }; - - if (includeInstance) { - obj.$jspbMessageInstance = msg; - } - return obj; -}; -} - - -/** - * Deserializes binary data (in protobuf wire format). - * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.ShutdownSessionMessage} - */ -proto.ShutdownSessionMessage.deserializeBinary = function(bytes) { - var reader = new jspb.BinaryReader(bytes); - var msg = new proto.ShutdownSessionMessage; - return proto.ShutdownSessionMessage.deserializeBinaryFromReader(msg, reader); -}; - - -/** - * Deserializes binary data (in protobuf wire format) from the - * given reader into the given message object. - * @param {!proto.ShutdownSessionMessage} msg The message object to deserialize into. - * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.ShutdownSessionMessage} - */ -proto.ShutdownSessionMessage.deserializeBinaryFromReader = function(msg, reader) { - while (reader.nextField()) { - if (reader.isEndGroup()) { - break; - } - var field = reader.getFieldNumber(); - switch (field) { - case 1: - var value = /** @type {number} */ (reader.readUint64()); - msg.setId(value); - break; - case 2: - var value = /** @type {string} */ (reader.readString()); - msg.setSignal(value); - break; - default: - reader.skipField(); - break; - } - } - return msg; -}; - - -/** - * Class method variant: serializes the given message to binary data - * (in protobuf wire format), writing to the given BinaryWriter. - * @param {!proto.ShutdownSessionMessage} message - * @param {!jspb.BinaryWriter} writer - */ -proto.ShutdownSessionMessage.serializeBinaryToWriter = function(message, writer) { - message.serializeBinaryToWriter(writer); -}; - - -/** - * Serializes the message to binary data (in protobuf wire format). - * @return {!Uint8Array} - */ -proto.ShutdownSessionMessage.prototype.serializeBinary = function() { - var writer = new jspb.BinaryWriter(); - this.serializeBinaryToWriter(writer); - return writer.getResultBuffer(); -}; - - -/** - * Serializes the message to binary data (in protobuf wire format), - * writing to the given BinaryWriter. - * @param {!jspb.BinaryWriter} writer - */ -proto.ShutdownSessionMessage.prototype.serializeBinaryToWriter = function (writer) { - var f = undefined; - f = this.getId(); - if (f !== 0) { - writer.writeUint64( - 1, - f - ); - } - f = this.getSignal(); - if (f.length > 0) { - writer.writeString( - 2, - f - ); - } -}; - - -/** - * Creates a deep clone of this proto. No data is shared with the original. - * @return {!proto.ShutdownSessionMessage} The clone. - */ -proto.ShutdownSessionMessage.prototype.cloneMessage = function() { - return /** @type {!proto.ShutdownSessionMessage} */ (jspb.Message.cloneMessage(this)); -}; - - -/** - * optional uint64 id = 1; - * @return {number} - */ -proto.ShutdownSessionMessage.prototype.getId = function() { - return /** @type {number} */ (jspb.Message.getFieldProto3(this, 1, 0)); -}; - - -/** @param {number} value */ -proto.ShutdownSessionMessage.prototype.setId = function(value) { - jspb.Message.setField(this, 1, value); -}; - - -/** - * optional string signal = 2; - * @return {string} - */ -proto.ShutdownSessionMessage.prototype.getSignal = function() { - return /** @type {string} */ (jspb.Message.getFieldProto3(this, 2, "")); -}; - - -/** @param {string} value */ -proto.ShutdownSessionMessage.prototype.setSignal = function(value) { - jspb.Message.setField(this, 2, value); -}; - - - -/** - * Generated by JsPbCodeGenerator. - * @param {Array=} opt_data Optional initial data array, typically from a - * server response, or constructed directly in Javascript. The array is used - * in place and becomes part of the constructed object. It is not cloned. - * If no data is provided, the constructed object will be empty, but still - * valid. - * @extends {jspb.Message} - * @constructor - */ -proto.SessionOutputMessage = function(opt_data) { - jspb.Message.initialize(this, opt_data, 0, -1, null, null); -}; -goog.inherits(proto.SessionOutputMessage, jspb.Message); -if (goog.DEBUG && !COMPILED) { - proto.SessionOutputMessage.displayName = 'proto.SessionOutputMessage'; -} - - -if (jspb.Message.GENERATE_TO_OBJECT) { -/** - * Creates an object representation of this proto suitable for use in Soy templates. - * Field names that are reserved in JavaScript and will be renamed to pb_name. - * To access a reserved field use, foo.pb_, eg, foo.pb_default. - * For the list of reserved names please see: - * com.google.apps.jspb.JsClassTemplate.JS_RESERVED_WORDS. - * @param {boolean=} opt_includeInstance Whether to include the JSPB instance - * for transitional soy proto support: http://goto/soy-param-migration - * @return {!Object} - */ -proto.SessionOutputMessage.prototype.toObject = function(opt_includeInstance) { - return proto.SessionOutputMessage.toObject(opt_includeInstance, this); -}; - - -/** - * Static version of the {@see toObject} method. - * @param {boolean|undefined} includeInstance Whether to include the JSPB - * instance for transitional soy proto support: - * http://goto/soy-param-migration - * @param {!proto.SessionOutputMessage} msg The msg instance to transform. - * @return {!Object} - */ -proto.SessionOutputMessage.toObject = function(includeInstance, msg) { - var f, obj = { - id: msg.getId(), - source: msg.getSource(), - data: msg.getData_asB64() - }; - - if (includeInstance) { - obj.$jspbMessageInstance = msg; - } - return obj; -}; -} - - -/** - * Deserializes binary data (in protobuf wire format). - * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.SessionOutputMessage} - */ -proto.SessionOutputMessage.deserializeBinary = function(bytes) { - var reader = new jspb.BinaryReader(bytes); - var msg = new proto.SessionOutputMessage; - return proto.SessionOutputMessage.deserializeBinaryFromReader(msg, reader); -}; - - -/** - * Deserializes binary data (in protobuf wire format) from the - * given reader into the given message object. - * @param {!proto.SessionOutputMessage} msg The message object to deserialize into. - * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.SessionOutputMessage} - */ -proto.SessionOutputMessage.deserializeBinaryFromReader = function(msg, reader) { - while (reader.nextField()) { - if (reader.isEndGroup()) { - break; - } - var field = reader.getFieldNumber(); - switch (field) { - case 1: - var value = /** @type {number} */ (reader.readUint64()); - msg.setId(value); - break; - case 2: - var value = /** @type {!proto.SessionOutputMessage.Source} */ (reader.readEnum()); - msg.setSource(value); - break; - case 3: - var value = /** @type {!Uint8Array} */ (reader.readBytes()); - msg.setData(value); - break; - default: - reader.skipField(); - break; - } - } - return msg; -}; - - -/** - * Class method variant: serializes the given message to binary data - * (in protobuf wire format), writing to the given BinaryWriter. - * @param {!proto.SessionOutputMessage} message - * @param {!jspb.BinaryWriter} writer - */ -proto.SessionOutputMessage.serializeBinaryToWriter = function(message, writer) { - message.serializeBinaryToWriter(writer); -}; - - -/** - * Serializes the message to binary data (in protobuf wire format). - * @return {!Uint8Array} - */ -proto.SessionOutputMessage.prototype.serializeBinary = function() { - var writer = new jspb.BinaryWriter(); - this.serializeBinaryToWriter(writer); - return writer.getResultBuffer(); -}; - - -/** - * Serializes the message to binary data (in protobuf wire format), - * writing to the given BinaryWriter. - * @param {!jspb.BinaryWriter} writer - */ -proto.SessionOutputMessage.prototype.serializeBinaryToWriter = function (writer) { - var f = undefined; - f = this.getId(); - if (f !== 0) { - writer.writeUint64( - 1, - f - ); - } - f = this.getSource(); - if (f !== 0.0) { - writer.writeEnum( - 2, - f - ); - } - f = this.getData_asU8(); - if (f.length > 0) { - writer.writeBytes( - 3, - f - ); - } -}; - - -/** - * Creates a deep clone of this proto. No data is shared with the original. - * @return {!proto.SessionOutputMessage} The clone. - */ -proto.SessionOutputMessage.prototype.cloneMessage = function() { - return /** @type {!proto.SessionOutputMessage} */ (jspb.Message.cloneMessage(this)); -}; - - -/** - * optional uint64 id = 1; - * @return {number} - */ -proto.SessionOutputMessage.prototype.getId = function() { - return /** @type {number} */ (jspb.Message.getFieldProto3(this, 1, 0)); -}; - - -/** @param {number} value */ -proto.SessionOutputMessage.prototype.setId = function(value) { - jspb.Message.setField(this, 1, value); -}; - - -/** - * optional Source source = 2; - * @return {!proto.SessionOutputMessage.Source} - */ -proto.SessionOutputMessage.prototype.getSource = function() { - return /** @type {!proto.SessionOutputMessage.Source} */ (jspb.Message.getFieldProto3(this, 2, 0)); -}; - - -/** @param {!proto.SessionOutputMessage.Source} value */ -proto.SessionOutputMessage.prototype.setSource = function(value) { - jspb.Message.setField(this, 2, value); -}; - - -/** - * optional bytes data = 3; - * @return {!(string|Uint8Array)} - */ -proto.SessionOutputMessage.prototype.getData = function() { - return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldProto3(this, 3, "")); -}; - - -/** - * optional bytes data = 3; - * This is a type-conversion wrapper around `getData()` - * @return {string} - */ -proto.SessionOutputMessage.prototype.getData_asB64 = function() { - return /** @type {string} */ (jspb.Message.bytesAsB64( - this.getData())); -}; - - -/** - * optional bytes data = 3; - * Note that Uint8Array is not supported on all browsers. - * @see http://caniuse.com/Uint8Array - * This is a type-conversion wrapper around `getData()` - * @return {!Uint8Array} - */ -proto.SessionOutputMessage.prototype.getData_asU8 = function() { - return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( - this.getData())); -}; - - -/** @param {!(string|Uint8Array)} value */ -proto.SessionOutputMessage.prototype.setData = function(value) { - jspb.Message.setField(this, 3, value); -}; - - -/** - * @enum {number} - */ -proto.SessionOutputMessage.Source = { - STDOUT: 0, - STDERR: 1, - IPC: 2 -}; - - -/** - * Generated by JsPbCodeGenerator. - * @param {Array=} opt_data Optional initial data array, typically from a - * server response, or constructed directly in Javascript. The array is used - * in place and becomes part of the constructed object. It is not cloned. - * If no data is provided, the constructed object will be empty, but still - * valid. - * @extends {jspb.Message} - * @constructor - */ -proto.TTYDimensions = function(opt_data) { - jspb.Message.initialize(this, opt_data, 0, -1, null, null); -}; -goog.inherits(proto.TTYDimensions, jspb.Message); -if (goog.DEBUG && !COMPILED) { - proto.TTYDimensions.displayName = 'proto.TTYDimensions'; -} - - -if (jspb.Message.GENERATE_TO_OBJECT) { -/** - * Creates an object representation of this proto suitable for use in Soy templates. - * Field names that are reserved in JavaScript and will be renamed to pb_name. - * To access a reserved field use, foo.pb_, eg, foo.pb_default. - * For the list of reserved names please see: - * com.google.apps.jspb.JsClassTemplate.JS_RESERVED_WORDS. - * @param {boolean=} opt_includeInstance Whether to include the JSPB instance - * for transitional soy proto support: http://goto/soy-param-migration - * @return {!Object} - */ -proto.TTYDimensions.prototype.toObject = function(opt_includeInstance) { - return proto.TTYDimensions.toObject(opt_includeInstance, this); -}; - - -/** - * Static version of the {@see toObject} method. - * @param {boolean|undefined} includeInstance Whether to include the JSPB - * instance for transitional soy proto support: - * http://goto/soy-param-migration - * @param {!proto.TTYDimensions} msg The msg instance to transform. - * @return {!Object} - */ -proto.TTYDimensions.toObject = function(includeInstance, msg) { - var f, obj = { - height: msg.getHeight(), - width: msg.getWidth() - }; - - if (includeInstance) { - obj.$jspbMessageInstance = msg; - } - return obj; -}; -} - - -/** - * Deserializes binary data (in protobuf wire format). - * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.TTYDimensions} - */ -proto.TTYDimensions.deserializeBinary = function(bytes) { - var reader = new jspb.BinaryReader(bytes); - var msg = new proto.TTYDimensions; - return proto.TTYDimensions.deserializeBinaryFromReader(msg, reader); -}; - - -/** - * Deserializes binary data (in protobuf wire format) from the - * given reader into the given message object. - * @param {!proto.TTYDimensions} msg The message object to deserialize into. - * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.TTYDimensions} - */ -proto.TTYDimensions.deserializeBinaryFromReader = function(msg, reader) { - while (reader.nextField()) { - if (reader.isEndGroup()) { - break; - } - var field = reader.getFieldNumber(); - switch (field) { - case 1: - var value = /** @type {number} */ (reader.readUint32()); - msg.setHeight(value); - break; - case 2: - var value = /** @type {number} */ (reader.readUint32()); - msg.setWidth(value); - break; - default: - reader.skipField(); - break; - } - } - return msg; -}; - - -/** - * Class method variant: serializes the given message to binary data - * (in protobuf wire format), writing to the given BinaryWriter. - * @param {!proto.TTYDimensions} message - * @param {!jspb.BinaryWriter} writer - */ -proto.TTYDimensions.serializeBinaryToWriter = function(message, writer) { - message.serializeBinaryToWriter(writer); -}; - - -/** - * Serializes the message to binary data (in protobuf wire format). - * @return {!Uint8Array} - */ -proto.TTYDimensions.prototype.serializeBinary = function() { - var writer = new jspb.BinaryWriter(); - this.serializeBinaryToWriter(writer); - return writer.getResultBuffer(); -}; - - -/** - * Serializes the message to binary data (in protobuf wire format), - * writing to the given BinaryWriter. - * @param {!jspb.BinaryWriter} writer - */ -proto.TTYDimensions.prototype.serializeBinaryToWriter = function (writer) { - var f = undefined; - f = this.getHeight(); - if (f !== 0) { - writer.writeUint32( - 1, - f - ); - } - f = this.getWidth(); - if (f !== 0) { - writer.writeUint32( - 2, - f - ); - } -}; - - -/** - * Creates a deep clone of this proto. No data is shared with the original. - * @return {!proto.TTYDimensions} The clone. - */ -proto.TTYDimensions.prototype.cloneMessage = function() { - return /** @type {!proto.TTYDimensions} */ (jspb.Message.cloneMessage(this)); -}; - - -/** - * optional uint32 height = 1; - * @return {number} - */ -proto.TTYDimensions.prototype.getHeight = function() { - return /** @type {number} */ (jspb.Message.getFieldProto3(this, 1, 0)); -}; - - -/** @param {number} value */ -proto.TTYDimensions.prototype.setHeight = function(value) { - jspb.Message.setField(this, 1, value); -}; - - -/** - * optional uint32 width = 2; - * @return {number} - */ -proto.TTYDimensions.prototype.getWidth = function() { - return /** @type {number} */ (jspb.Message.getFieldProto3(this, 2, 0)); -}; - - -/** @param {number} value */ -proto.TTYDimensions.prototype.setWidth = function(value) { - jspb.Message.setField(this, 2, value); -}; - - - -/** - * Generated by JsPbCodeGenerator. - * @param {Array=} opt_data Optional initial data array, typically from a - * server response, or constructed directly in Javascript. The array is used - * in place and becomes part of the constructed object. It is not cloned. - * If no data is provided, the constructed object will be empty, but still - * valid. - * @extends {jspb.Message} - * @constructor - */ -proto.NewConnectionMessage = function(opt_data) { - jspb.Message.initialize(this, opt_data, 0, -1, null, null); -}; -goog.inherits(proto.NewConnectionMessage, jspb.Message); -if (goog.DEBUG && !COMPILED) { - proto.NewConnectionMessage.displayName = 'proto.NewConnectionMessage'; -} - - -if (jspb.Message.GENERATE_TO_OBJECT) { -/** - * Creates an object representation of this proto suitable for use in Soy templates. - * Field names that are reserved in JavaScript and will be renamed to pb_name. - * To access a reserved field use, foo.pb_, eg, foo.pb_default. - * For the list of reserved names please see: - * com.google.apps.jspb.JsClassTemplate.JS_RESERVED_WORDS. - * @param {boolean=} opt_includeInstance Whether to include the JSPB instance - * for transitional soy proto support: http://goto/soy-param-migration - * @return {!Object} - */ -proto.NewConnectionMessage.prototype.toObject = function(opt_includeInstance) { - return proto.NewConnectionMessage.toObject(opt_includeInstance, this); -}; - - -/** - * Static version of the {@see toObject} method. - * @param {boolean|undefined} includeInstance Whether to include the JSPB - * instance for transitional soy proto support: - * http://goto/soy-param-migration - * @param {!proto.NewConnectionMessage} msg The msg instance to transform. - * @return {!Object} - */ -proto.NewConnectionMessage.toObject = function(includeInstance, msg) { - var f, obj = { - id: msg.getId(), - port: msg.getPort(), - path: msg.getPath() - }; - - if (includeInstance) { - obj.$jspbMessageInstance = msg; - } - return obj; -}; -} - - -/** - * Deserializes binary data (in protobuf wire format). - * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.NewConnectionMessage} - */ -proto.NewConnectionMessage.deserializeBinary = function(bytes) { - var reader = new jspb.BinaryReader(bytes); - var msg = new proto.NewConnectionMessage; - return proto.NewConnectionMessage.deserializeBinaryFromReader(msg, reader); -}; - - -/** - * Deserializes binary data (in protobuf wire format) from the - * given reader into the given message object. - * @param {!proto.NewConnectionMessage} msg The message object to deserialize into. - * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.NewConnectionMessage} - */ -proto.NewConnectionMessage.deserializeBinaryFromReader = function(msg, reader) { - while (reader.nextField()) { - if (reader.isEndGroup()) { - break; - } - var field = reader.getFieldNumber(); - switch (field) { - case 1: - var value = /** @type {number} */ (reader.readUint64()); - msg.setId(value); - break; - case 2: - var value = /** @type {number} */ (reader.readUint64()); - msg.setPort(value); - break; - case 3: - var value = /** @type {string} */ (reader.readString()); - msg.setPath(value); - break; - default: - reader.skipField(); - break; - } - } - return msg; -}; - - -/** - * Class method variant: serializes the given message to binary data - * (in protobuf wire format), writing to the given BinaryWriter. - * @param {!proto.NewConnectionMessage} message - * @param {!jspb.BinaryWriter} writer - */ -proto.NewConnectionMessage.serializeBinaryToWriter = function(message, writer) { - message.serializeBinaryToWriter(writer); -}; - - -/** - * Serializes the message to binary data (in protobuf wire format). - * @return {!Uint8Array} - */ -proto.NewConnectionMessage.prototype.serializeBinary = function() { - var writer = new jspb.BinaryWriter(); - this.serializeBinaryToWriter(writer); - return writer.getResultBuffer(); -}; - - -/** - * Serializes the message to binary data (in protobuf wire format), - * writing to the given BinaryWriter. - * @param {!jspb.BinaryWriter} writer - */ -proto.NewConnectionMessage.prototype.serializeBinaryToWriter = function (writer) { - var f = undefined; - f = this.getId(); - if (f !== 0) { - writer.writeUint64( - 1, - f - ); - } - f = this.getPort(); - if (f !== 0) { - writer.writeUint64( - 2, - f - ); - } - f = this.getPath(); - if (f.length > 0) { - writer.writeString( - 3, - f - ); - } -}; - - -/** - * Creates a deep clone of this proto. No data is shared with the original. - * @return {!proto.NewConnectionMessage} The clone. - */ -proto.NewConnectionMessage.prototype.cloneMessage = function() { - return /** @type {!proto.NewConnectionMessage} */ (jspb.Message.cloneMessage(this)); -}; - - -/** - * optional uint64 id = 1; - * @return {number} - */ -proto.NewConnectionMessage.prototype.getId = function() { - return /** @type {number} */ (jspb.Message.getFieldProto3(this, 1, 0)); -}; - - -/** @param {number} value */ -proto.NewConnectionMessage.prototype.setId = function(value) { - jspb.Message.setField(this, 1, value); -}; - - -/** - * optional uint64 port = 2; - * @return {number} - */ -proto.NewConnectionMessage.prototype.getPort = function() { - return /** @type {number} */ (jspb.Message.getFieldProto3(this, 2, 0)); -}; - - -/** @param {number} value */ -proto.NewConnectionMessage.prototype.setPort = function(value) { - jspb.Message.setField(this, 2, value); -}; - - -/** - * optional string path = 3; - * @return {string} - */ -proto.NewConnectionMessage.prototype.getPath = function() { - return /** @type {string} */ (jspb.Message.getFieldProto3(this, 3, "")); -}; - - -/** @param {string} value */ -proto.NewConnectionMessage.prototype.setPath = function(value) { - jspb.Message.setField(this, 3, value); -}; - - - -/** - * Generated by JsPbCodeGenerator. - * @param {Array=} opt_data Optional initial data array, typically from a - * server response, or constructed directly in Javascript. The array is used - * in place and becomes part of the constructed object. It is not cloned. - * If no data is provided, the constructed object will be empty, but still - * valid. - * @extends {jspb.Message} - * @constructor - */ -proto.ConnectionEstablishedMessage = function(opt_data) { - jspb.Message.initialize(this, opt_data, 0, -1, null, null); -}; -goog.inherits(proto.ConnectionEstablishedMessage, jspb.Message); -if (goog.DEBUG && !COMPILED) { - proto.ConnectionEstablishedMessage.displayName = 'proto.ConnectionEstablishedMessage'; -} - - -if (jspb.Message.GENERATE_TO_OBJECT) { -/** - * Creates an object representation of this proto suitable for use in Soy templates. - * Field names that are reserved in JavaScript and will be renamed to pb_name. - * To access a reserved field use, foo.pb_, eg, foo.pb_default. - * For the list of reserved names please see: - * com.google.apps.jspb.JsClassTemplate.JS_RESERVED_WORDS. - * @param {boolean=} opt_includeInstance Whether to include the JSPB instance - * for transitional soy proto support: http://goto/soy-param-migration - * @return {!Object} - */ -proto.ConnectionEstablishedMessage.prototype.toObject = function(opt_includeInstance) { - return proto.ConnectionEstablishedMessage.toObject(opt_includeInstance, this); -}; - - -/** - * Static version of the {@see toObject} method. - * @param {boolean|undefined} includeInstance Whether to include the JSPB - * instance for transitional soy proto support: - * http://goto/soy-param-migration - * @param {!proto.ConnectionEstablishedMessage} msg The msg instance to transform. - * @return {!Object} - */ -proto.ConnectionEstablishedMessage.toObject = function(includeInstance, msg) { - var f, obj = { - id: msg.getId() - }; - - if (includeInstance) { - obj.$jspbMessageInstance = msg; - } - return obj; -}; -} - - -/** - * Deserializes binary data (in protobuf wire format). - * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.ConnectionEstablishedMessage} - */ -proto.ConnectionEstablishedMessage.deserializeBinary = function(bytes) { - var reader = new jspb.BinaryReader(bytes); - var msg = new proto.ConnectionEstablishedMessage; - return proto.ConnectionEstablishedMessage.deserializeBinaryFromReader(msg, reader); -}; - - -/** - * Deserializes binary data (in protobuf wire format) from the - * given reader into the given message object. - * @param {!proto.ConnectionEstablishedMessage} msg The message object to deserialize into. - * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.ConnectionEstablishedMessage} - */ -proto.ConnectionEstablishedMessage.deserializeBinaryFromReader = function(msg, reader) { - while (reader.nextField()) { - if (reader.isEndGroup()) { - break; - } - var field = reader.getFieldNumber(); - switch (field) { - case 1: - var value = /** @type {number} */ (reader.readUint64()); - msg.setId(value); - break; - default: - reader.skipField(); - break; - } - } - return msg; -}; - - -/** - * Class method variant: serializes the given message to binary data - * (in protobuf wire format), writing to the given BinaryWriter. - * @param {!proto.ConnectionEstablishedMessage} message - * @param {!jspb.BinaryWriter} writer - */ -proto.ConnectionEstablishedMessage.serializeBinaryToWriter = function(message, writer) { - message.serializeBinaryToWriter(writer); -}; - - -/** - * Serializes the message to binary data (in protobuf wire format). - * @return {!Uint8Array} - */ -proto.ConnectionEstablishedMessage.prototype.serializeBinary = function() { - var writer = new jspb.BinaryWriter(); - this.serializeBinaryToWriter(writer); - return writer.getResultBuffer(); -}; - - -/** - * Serializes the message to binary data (in protobuf wire format), - * writing to the given BinaryWriter. - * @param {!jspb.BinaryWriter} writer - */ -proto.ConnectionEstablishedMessage.prototype.serializeBinaryToWriter = function (writer) { - var f = undefined; - f = this.getId(); - if (f !== 0) { - writer.writeUint64( - 1, - f - ); - } -}; - - -/** - * Creates a deep clone of this proto. No data is shared with the original. - * @return {!proto.ConnectionEstablishedMessage} The clone. - */ -proto.ConnectionEstablishedMessage.prototype.cloneMessage = function() { - return /** @type {!proto.ConnectionEstablishedMessage} */ (jspb.Message.cloneMessage(this)); -}; - - -/** - * optional uint64 id = 1; - * @return {number} - */ -proto.ConnectionEstablishedMessage.prototype.getId = function() { - return /** @type {number} */ (jspb.Message.getFieldProto3(this, 1, 0)); -}; - - -/** @param {number} value */ -proto.ConnectionEstablishedMessage.prototype.setId = function(value) { - jspb.Message.setField(this, 1, value); -}; - - - -/** - * Generated by JsPbCodeGenerator. - * @param {Array=} opt_data Optional initial data array, typically from a - * server response, or constructed directly in Javascript. The array is used - * in place and becomes part of the constructed object. It is not cloned. - * If no data is provided, the constructed object will be empty, but still - * valid. - * @extends {jspb.Message} - * @constructor - */ -proto.NewConnectionFailureMessage = function(opt_data) { - jspb.Message.initialize(this, opt_data, 0, -1, null, null); -}; -goog.inherits(proto.NewConnectionFailureMessage, jspb.Message); -if (goog.DEBUG && !COMPILED) { - proto.NewConnectionFailureMessage.displayName = 'proto.NewConnectionFailureMessage'; -} - - -if (jspb.Message.GENERATE_TO_OBJECT) { -/** - * Creates an object representation of this proto suitable for use in Soy templates. - * Field names that are reserved in JavaScript and will be renamed to pb_name. - * To access a reserved field use, foo.pb_, eg, foo.pb_default. - * For the list of reserved names please see: - * com.google.apps.jspb.JsClassTemplate.JS_RESERVED_WORDS. - * @param {boolean=} opt_includeInstance Whether to include the JSPB instance - * for transitional soy proto support: http://goto/soy-param-migration - * @return {!Object} - */ -proto.NewConnectionFailureMessage.prototype.toObject = function(opt_includeInstance) { - return proto.NewConnectionFailureMessage.toObject(opt_includeInstance, this); -}; - - -/** - * Static version of the {@see toObject} method. - * @param {boolean|undefined} includeInstance Whether to include the JSPB - * instance for transitional soy proto support: - * http://goto/soy-param-migration - * @param {!proto.NewConnectionFailureMessage} msg The msg instance to transform. - * @return {!Object} - */ -proto.NewConnectionFailureMessage.toObject = function(includeInstance, msg) { - var f, obj = { - id: msg.getId(), - message: msg.getMessage() - }; - - if (includeInstance) { - obj.$jspbMessageInstance = msg; - } - return obj; -}; -} - - -/** - * Deserializes binary data (in protobuf wire format). - * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.NewConnectionFailureMessage} - */ -proto.NewConnectionFailureMessage.deserializeBinary = function(bytes) { - var reader = new jspb.BinaryReader(bytes); - var msg = new proto.NewConnectionFailureMessage; - return proto.NewConnectionFailureMessage.deserializeBinaryFromReader(msg, reader); -}; - - -/** - * Deserializes binary data (in protobuf wire format) from the - * given reader into the given message object. - * @param {!proto.NewConnectionFailureMessage} msg The message object to deserialize into. - * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.NewConnectionFailureMessage} - */ -proto.NewConnectionFailureMessage.deserializeBinaryFromReader = function(msg, reader) { - while (reader.nextField()) { - if (reader.isEndGroup()) { - break; - } - var field = reader.getFieldNumber(); - switch (field) { - case 1: - var value = /** @type {number} */ (reader.readUint64()); - msg.setId(value); - break; - case 2: - var value = /** @type {string} */ (reader.readString()); - msg.setMessage(value); - break; - default: - reader.skipField(); - break; - } - } - return msg; -}; - - -/** - * Class method variant: serializes the given message to binary data - * (in protobuf wire format), writing to the given BinaryWriter. - * @param {!proto.NewConnectionFailureMessage} message - * @param {!jspb.BinaryWriter} writer - */ -proto.NewConnectionFailureMessage.serializeBinaryToWriter = function(message, writer) { - message.serializeBinaryToWriter(writer); -}; - - -/** - * Serializes the message to binary data (in protobuf wire format). - * @return {!Uint8Array} - */ -proto.NewConnectionFailureMessage.prototype.serializeBinary = function() { - var writer = new jspb.BinaryWriter(); - this.serializeBinaryToWriter(writer); - return writer.getResultBuffer(); -}; - - -/** - * Serializes the message to binary data (in protobuf wire format), - * writing to the given BinaryWriter. - * @param {!jspb.BinaryWriter} writer - */ -proto.NewConnectionFailureMessage.prototype.serializeBinaryToWriter = function (writer) { - var f = undefined; - f = this.getId(); - if (f !== 0) { - writer.writeUint64( - 1, - f - ); - } - f = this.getMessage(); - if (f.length > 0) { - writer.writeString( - 2, - f - ); - } -}; - - -/** - * Creates a deep clone of this proto. No data is shared with the original. - * @return {!proto.NewConnectionFailureMessage} The clone. - */ -proto.NewConnectionFailureMessage.prototype.cloneMessage = function() { - return /** @type {!proto.NewConnectionFailureMessage} */ (jspb.Message.cloneMessage(this)); -}; - - -/** - * optional uint64 id = 1; - * @return {number} - */ -proto.NewConnectionFailureMessage.prototype.getId = function() { - return /** @type {number} */ (jspb.Message.getFieldProto3(this, 1, 0)); -}; - - -/** @param {number} value */ -proto.NewConnectionFailureMessage.prototype.setId = function(value) { - jspb.Message.setField(this, 1, value); -}; - - -/** - * optional string message = 2; - * @return {string} - */ -proto.NewConnectionFailureMessage.prototype.getMessage = function() { - return /** @type {string} */ (jspb.Message.getFieldProto3(this, 2, "")); -}; - - -/** @param {string} value */ -proto.NewConnectionFailureMessage.prototype.setMessage = function(value) { - jspb.Message.setField(this, 2, value); -}; - - - -/** - * Generated by JsPbCodeGenerator. - * @param {Array=} opt_data Optional initial data array, typically from a - * server response, or constructed directly in Javascript. The array is used - * in place and becomes part of the constructed object. It is not cloned. - * If no data is provided, the constructed object will be empty, but still - * valid. - * @extends {jspb.Message} - * @constructor - */ -proto.ConnectionOutputMessage = function(opt_data) { - jspb.Message.initialize(this, opt_data, 0, -1, null, null); -}; -goog.inherits(proto.ConnectionOutputMessage, jspb.Message); -if (goog.DEBUG && !COMPILED) { - proto.ConnectionOutputMessage.displayName = 'proto.ConnectionOutputMessage'; -} - - -if (jspb.Message.GENERATE_TO_OBJECT) { -/** - * Creates an object representation of this proto suitable for use in Soy templates. - * Field names that are reserved in JavaScript and will be renamed to pb_name. - * To access a reserved field use, foo.pb_, eg, foo.pb_default. - * For the list of reserved names please see: - * com.google.apps.jspb.JsClassTemplate.JS_RESERVED_WORDS. - * @param {boolean=} opt_includeInstance Whether to include the JSPB instance - * for transitional soy proto support: http://goto/soy-param-migration - * @return {!Object} - */ -proto.ConnectionOutputMessage.prototype.toObject = function(opt_includeInstance) { - return proto.ConnectionOutputMessage.toObject(opt_includeInstance, this); -}; - - -/** - * Static version of the {@see toObject} method. - * @param {boolean|undefined} includeInstance Whether to include the JSPB - * instance for transitional soy proto support: - * http://goto/soy-param-migration - * @param {!proto.ConnectionOutputMessage} msg The msg instance to transform. - * @return {!Object} - */ -proto.ConnectionOutputMessage.toObject = function(includeInstance, msg) { - var f, obj = { - id: msg.getId(), - data: msg.getData_asB64() - }; - - if (includeInstance) { - obj.$jspbMessageInstance = msg; - } - return obj; -}; -} - - -/** - * Deserializes binary data (in protobuf wire format). - * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.ConnectionOutputMessage} - */ -proto.ConnectionOutputMessage.deserializeBinary = function(bytes) { - var reader = new jspb.BinaryReader(bytes); - var msg = new proto.ConnectionOutputMessage; - return proto.ConnectionOutputMessage.deserializeBinaryFromReader(msg, reader); -}; - - -/** - * Deserializes binary data (in protobuf wire format) from the - * given reader into the given message object. - * @param {!proto.ConnectionOutputMessage} msg The message object to deserialize into. - * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.ConnectionOutputMessage} - */ -proto.ConnectionOutputMessage.deserializeBinaryFromReader = function(msg, reader) { - while (reader.nextField()) { - if (reader.isEndGroup()) { - break; - } - var field = reader.getFieldNumber(); - switch (field) { - case 1: - var value = /** @type {number} */ (reader.readUint64()); - msg.setId(value); - break; - case 2: - var value = /** @type {!Uint8Array} */ (reader.readBytes()); - msg.setData(value); - break; - default: - reader.skipField(); - break; - } - } - return msg; -}; - - -/** - * Class method variant: serializes the given message to binary data - * (in protobuf wire format), writing to the given BinaryWriter. - * @param {!proto.ConnectionOutputMessage} message - * @param {!jspb.BinaryWriter} writer - */ -proto.ConnectionOutputMessage.serializeBinaryToWriter = function(message, writer) { - message.serializeBinaryToWriter(writer); -}; - - -/** - * Serializes the message to binary data (in protobuf wire format). - * @return {!Uint8Array} - */ -proto.ConnectionOutputMessage.prototype.serializeBinary = function() { - var writer = new jspb.BinaryWriter(); - this.serializeBinaryToWriter(writer); - return writer.getResultBuffer(); -}; - - -/** - * Serializes the message to binary data (in protobuf wire format), - * writing to the given BinaryWriter. - * @param {!jspb.BinaryWriter} writer - */ -proto.ConnectionOutputMessage.prototype.serializeBinaryToWriter = function (writer) { - var f = undefined; - f = this.getId(); - if (f !== 0) { - writer.writeUint64( - 1, - f - ); - } - f = this.getData_asU8(); - if (f.length > 0) { - writer.writeBytes( - 2, - f - ); - } -}; - - -/** - * Creates a deep clone of this proto. No data is shared with the original. - * @return {!proto.ConnectionOutputMessage} The clone. - */ -proto.ConnectionOutputMessage.prototype.cloneMessage = function() { - return /** @type {!proto.ConnectionOutputMessage} */ (jspb.Message.cloneMessage(this)); -}; - - -/** - * optional uint64 id = 1; - * @return {number} - */ -proto.ConnectionOutputMessage.prototype.getId = function() { - return /** @type {number} */ (jspb.Message.getFieldProto3(this, 1, 0)); -}; - - -/** @param {number} value */ -proto.ConnectionOutputMessage.prototype.setId = function(value) { - jspb.Message.setField(this, 1, value); -}; - - -/** - * optional bytes data = 2; - * @return {!(string|Uint8Array)} - */ -proto.ConnectionOutputMessage.prototype.getData = function() { - return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldProto3(this, 2, "")); -}; - - -/** - * optional bytes data = 2; - * This is a type-conversion wrapper around `getData()` - * @return {string} - */ -proto.ConnectionOutputMessage.prototype.getData_asB64 = function() { - return /** @type {string} */ (jspb.Message.bytesAsB64( - this.getData())); -}; - - -/** - * optional bytes data = 2; - * Note that Uint8Array is not supported on all browsers. - * @see http://caniuse.com/Uint8Array - * This is a type-conversion wrapper around `getData()` - * @return {!Uint8Array} - */ -proto.ConnectionOutputMessage.prototype.getData_asU8 = function() { - return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( - this.getData())); -}; - - -/** @param {!(string|Uint8Array)} value */ -proto.ConnectionOutputMessage.prototype.setData = function(value) { - jspb.Message.setField(this, 2, value); -}; - - - -/** - * Generated by JsPbCodeGenerator. - * @param {Array=} opt_data Optional initial data array, typically from a - * server response, or constructed directly in Javascript. The array is used - * in place and becomes part of the constructed object. It is not cloned. - * If no data is provided, the constructed object will be empty, but still - * valid. - * @extends {jspb.Message} - * @constructor - */ -proto.ConnectionCloseMessage = function(opt_data) { - jspb.Message.initialize(this, opt_data, 0, -1, null, null); -}; -goog.inherits(proto.ConnectionCloseMessage, jspb.Message); -if (goog.DEBUG && !COMPILED) { - proto.ConnectionCloseMessage.displayName = 'proto.ConnectionCloseMessage'; -} - - -if (jspb.Message.GENERATE_TO_OBJECT) { -/** - * Creates an object representation of this proto suitable for use in Soy templates. - * Field names that are reserved in JavaScript and will be renamed to pb_name. - * To access a reserved field use, foo.pb_, eg, foo.pb_default. - * For the list of reserved names please see: - * com.google.apps.jspb.JsClassTemplate.JS_RESERVED_WORDS. - * @param {boolean=} opt_includeInstance Whether to include the JSPB instance - * for transitional soy proto support: http://goto/soy-param-migration - * @return {!Object} - */ -proto.ConnectionCloseMessage.prototype.toObject = function(opt_includeInstance) { - return proto.ConnectionCloseMessage.toObject(opt_includeInstance, this); -}; - - -/** - * Static version of the {@see toObject} method. - * @param {boolean|undefined} includeInstance Whether to include the JSPB - * instance for transitional soy proto support: - * http://goto/soy-param-migration - * @param {!proto.ConnectionCloseMessage} msg The msg instance to transform. - * @return {!Object} - */ -proto.ConnectionCloseMessage.toObject = function(includeInstance, msg) { - var f, obj = { - id: msg.getId() - }; - - if (includeInstance) { - obj.$jspbMessageInstance = msg; - } - return obj; -}; -} - - -/** - * Deserializes binary data (in protobuf wire format). - * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.ConnectionCloseMessage} - */ -proto.ConnectionCloseMessage.deserializeBinary = function(bytes) { - var reader = new jspb.BinaryReader(bytes); - var msg = new proto.ConnectionCloseMessage; - return proto.ConnectionCloseMessage.deserializeBinaryFromReader(msg, reader); -}; - - -/** - * Deserializes binary data (in protobuf wire format) from the - * given reader into the given message object. - * @param {!proto.ConnectionCloseMessage} msg The message object to deserialize into. - * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.ConnectionCloseMessage} - */ -proto.ConnectionCloseMessage.deserializeBinaryFromReader = function(msg, reader) { - while (reader.nextField()) { - if (reader.isEndGroup()) { - break; - } - var field = reader.getFieldNumber(); - switch (field) { - case 1: - var value = /** @type {number} */ (reader.readUint64()); - msg.setId(value); - break; - default: - reader.skipField(); - break; - } - } - return msg; -}; - - -/** - * Class method variant: serializes the given message to binary data - * (in protobuf wire format), writing to the given BinaryWriter. - * @param {!proto.ConnectionCloseMessage} message - * @param {!jspb.BinaryWriter} writer - */ -proto.ConnectionCloseMessage.serializeBinaryToWriter = function(message, writer) { - message.serializeBinaryToWriter(writer); -}; - - -/** - * Serializes the message to binary data (in protobuf wire format). - * @return {!Uint8Array} - */ -proto.ConnectionCloseMessage.prototype.serializeBinary = function() { - var writer = new jspb.BinaryWriter(); - this.serializeBinaryToWriter(writer); - return writer.getResultBuffer(); -}; - - -/** - * Serializes the message to binary data (in protobuf wire format), - * writing to the given BinaryWriter. - * @param {!jspb.BinaryWriter} writer - */ -proto.ConnectionCloseMessage.prototype.serializeBinaryToWriter = function (writer) { - var f = undefined; - f = this.getId(); - if (f !== 0) { - writer.writeUint64( - 1, - f - ); - } -}; - - -/** - * Creates a deep clone of this proto. No data is shared with the original. - * @return {!proto.ConnectionCloseMessage} The clone. - */ -proto.ConnectionCloseMessage.prototype.cloneMessage = function() { - return /** @type {!proto.ConnectionCloseMessage} */ (jspb.Message.cloneMessage(this)); -}; - - -/** - * optional uint64 id = 1; - * @return {number} - */ -proto.ConnectionCloseMessage.prototype.getId = function() { - return /** @type {number} */ (jspb.Message.getFieldProto3(this, 1, 0)); -}; - - -/** @param {number} value */ -proto.ConnectionCloseMessage.prototype.setId = function(value) { - jspb.Message.setField(this, 1, value); -}; - - - -/** - * Generated by JsPbCodeGenerator. - * @param {Array=} opt_data Optional initial data array, typically from a - * server response, or constructed directly in Javascript. The array is used - * in place and becomes part of the constructed object. It is not cloned. - * If no data is provided, the constructed object will be empty, but still - * valid. - * @extends {jspb.Message} - * @constructor - */ -proto.NewServerMessage = function(opt_data) { - jspb.Message.initialize(this, opt_data, 0, -1, null, null); -}; -goog.inherits(proto.NewServerMessage, jspb.Message); -if (goog.DEBUG && !COMPILED) { - proto.NewServerMessage.displayName = 'proto.NewServerMessage'; -} - - -if (jspb.Message.GENERATE_TO_OBJECT) { -/** - * Creates an object representation of this proto suitable for use in Soy templates. - * Field names that are reserved in JavaScript and will be renamed to pb_name. - * To access a reserved field use, foo.pb_, eg, foo.pb_default. - * For the list of reserved names please see: - * com.google.apps.jspb.JsClassTemplate.JS_RESERVED_WORDS. - * @param {boolean=} opt_includeInstance Whether to include the JSPB instance - * for transitional soy proto support: http://goto/soy-param-migration - * @return {!Object} - */ -proto.NewServerMessage.prototype.toObject = function(opt_includeInstance) { - return proto.NewServerMessage.toObject(opt_includeInstance, this); -}; - - -/** - * Static version of the {@see toObject} method. - * @param {boolean|undefined} includeInstance Whether to include the JSPB - * instance for transitional soy proto support: - * http://goto/soy-param-migration - * @param {!proto.NewServerMessage} msg The msg instance to transform. - * @return {!Object} - */ -proto.NewServerMessage.toObject = function(includeInstance, msg) { - var f, obj = { - id: msg.getId(), - port: msg.getPort(), - path: msg.getPath() - }; - - if (includeInstance) { - obj.$jspbMessageInstance = msg; - } - return obj; -}; -} - - -/** - * Deserializes binary data (in protobuf wire format). - * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.NewServerMessage} - */ -proto.NewServerMessage.deserializeBinary = function(bytes) { - var reader = new jspb.BinaryReader(bytes); - var msg = new proto.NewServerMessage; - return proto.NewServerMessage.deserializeBinaryFromReader(msg, reader); -}; - - -/** - * Deserializes binary data (in protobuf wire format) from the - * given reader into the given message object. - * @param {!proto.NewServerMessage} msg The message object to deserialize into. - * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.NewServerMessage} - */ -proto.NewServerMessage.deserializeBinaryFromReader = function(msg, reader) { - while (reader.nextField()) { - if (reader.isEndGroup()) { - break; - } - var field = reader.getFieldNumber(); - switch (field) { - case 1: - var value = /** @type {number} */ (reader.readUint64()); - msg.setId(value); - break; - case 2: - var value = /** @type {number} */ (reader.readUint64()); - msg.setPort(value); - break; - case 3: - var value = /** @type {string} */ (reader.readString()); - msg.setPath(value); - break; - default: - reader.skipField(); - break; - } - } - return msg; -}; - - -/** - * Class method variant: serializes the given message to binary data - * (in protobuf wire format), writing to the given BinaryWriter. - * @param {!proto.NewServerMessage} message - * @param {!jspb.BinaryWriter} writer - */ -proto.NewServerMessage.serializeBinaryToWriter = function(message, writer) { - message.serializeBinaryToWriter(writer); -}; - - -/** - * Serializes the message to binary data (in protobuf wire format). - * @return {!Uint8Array} - */ -proto.NewServerMessage.prototype.serializeBinary = function() { - var writer = new jspb.BinaryWriter(); - this.serializeBinaryToWriter(writer); - return writer.getResultBuffer(); -}; - - -/** - * Serializes the message to binary data (in protobuf wire format), - * writing to the given BinaryWriter. - * @param {!jspb.BinaryWriter} writer - */ -proto.NewServerMessage.prototype.serializeBinaryToWriter = function (writer) { - var f = undefined; - f = this.getId(); - if (f !== 0) { - writer.writeUint64( - 1, - f - ); - } - f = this.getPort(); - if (f !== 0) { - writer.writeUint64( - 2, - f - ); - } - f = this.getPath(); - if (f.length > 0) { - writer.writeString( - 3, - f - ); - } -}; - - -/** - * Creates a deep clone of this proto. No data is shared with the original. - * @return {!proto.NewServerMessage} The clone. - */ -proto.NewServerMessage.prototype.cloneMessage = function() { - return /** @type {!proto.NewServerMessage} */ (jspb.Message.cloneMessage(this)); -}; - - -/** - * optional uint64 id = 1; - * @return {number} - */ -proto.NewServerMessage.prototype.getId = function() { - return /** @type {number} */ (jspb.Message.getFieldProto3(this, 1, 0)); -}; - - -/** @param {number} value */ -proto.NewServerMessage.prototype.setId = function(value) { - jspb.Message.setField(this, 1, value); -}; - - -/** - * optional uint64 port = 2; - * @return {number} - */ -proto.NewServerMessage.prototype.getPort = function() { - return /** @type {number} */ (jspb.Message.getFieldProto3(this, 2, 0)); -}; - - -/** @param {number} value */ -proto.NewServerMessage.prototype.setPort = function(value) { - jspb.Message.setField(this, 2, value); -}; - - -/** - * optional string path = 3; - * @return {string} - */ -proto.NewServerMessage.prototype.getPath = function() { - return /** @type {string} */ (jspb.Message.getFieldProto3(this, 3, "")); -}; - - -/** @param {string} value */ -proto.NewServerMessage.prototype.setPath = function(value) { - jspb.Message.setField(this, 3, value); -}; - - - -/** - * Generated by JsPbCodeGenerator. - * @param {Array=} opt_data Optional initial data array, typically from a - * server response, or constructed directly in Javascript. The array is used - * in place and becomes part of the constructed object. It is not cloned. - * If no data is provided, the constructed object will be empty, but still - * valid. - * @extends {jspb.Message} - * @constructor - */ -proto.NewServerFailureMessage = function(opt_data) { - jspb.Message.initialize(this, opt_data, 0, -1, null, null); -}; -goog.inherits(proto.NewServerFailureMessage, jspb.Message); -if (goog.DEBUG && !COMPILED) { - proto.NewServerFailureMessage.displayName = 'proto.NewServerFailureMessage'; -} - - -if (jspb.Message.GENERATE_TO_OBJECT) { -/** - * Creates an object representation of this proto suitable for use in Soy templates. - * Field names that are reserved in JavaScript and will be renamed to pb_name. - * To access a reserved field use, foo.pb_, eg, foo.pb_default. - * For the list of reserved names please see: - * com.google.apps.jspb.JsClassTemplate.JS_RESERVED_WORDS. - * @param {boolean=} opt_includeInstance Whether to include the JSPB instance - * for transitional soy proto support: http://goto/soy-param-migration - * @return {!Object} - */ -proto.NewServerFailureMessage.prototype.toObject = function(opt_includeInstance) { - return proto.NewServerFailureMessage.toObject(opt_includeInstance, this); -}; - - -/** - * Static version of the {@see toObject} method. - * @param {boolean|undefined} includeInstance Whether to include the JSPB - * instance for transitional soy proto support: - * http://goto/soy-param-migration - * @param {!proto.NewServerFailureMessage} msg The msg instance to transform. - * @return {!Object} - */ -proto.NewServerFailureMessage.toObject = function(includeInstance, msg) { - var f, obj = { - id: msg.getId(), - message: msg.getMessage() - }; - - if (includeInstance) { - obj.$jspbMessageInstance = msg; - } - return obj; -}; -} - - -/** - * Deserializes binary data (in protobuf wire format). - * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.NewServerFailureMessage} - */ -proto.NewServerFailureMessage.deserializeBinary = function(bytes) { - var reader = new jspb.BinaryReader(bytes); - var msg = new proto.NewServerFailureMessage; - return proto.NewServerFailureMessage.deserializeBinaryFromReader(msg, reader); -}; - - -/** - * Deserializes binary data (in protobuf wire format) from the - * given reader into the given message object. - * @param {!proto.NewServerFailureMessage} msg The message object to deserialize into. - * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.NewServerFailureMessage} - */ -proto.NewServerFailureMessage.deserializeBinaryFromReader = function(msg, reader) { - while (reader.nextField()) { - if (reader.isEndGroup()) { - break; - } - var field = reader.getFieldNumber(); - switch (field) { - case 1: - var value = /** @type {number} */ (reader.readUint64()); - msg.setId(value); - break; - case 2: - var value = /** @type {string} */ (reader.readString()); - msg.setMessage(value); - break; - default: - reader.skipField(); - break; - } - } - return msg; -}; - - -/** - * Class method variant: serializes the given message to binary data - * (in protobuf wire format), writing to the given BinaryWriter. - * @param {!proto.NewServerFailureMessage} message - * @param {!jspb.BinaryWriter} writer - */ -proto.NewServerFailureMessage.serializeBinaryToWriter = function(message, writer) { - message.serializeBinaryToWriter(writer); -}; - - -/** - * Serializes the message to binary data (in protobuf wire format). - * @return {!Uint8Array} - */ -proto.NewServerFailureMessage.prototype.serializeBinary = function() { - var writer = new jspb.BinaryWriter(); - this.serializeBinaryToWriter(writer); - return writer.getResultBuffer(); -}; - - -/** - * Serializes the message to binary data (in protobuf wire format), - * writing to the given BinaryWriter. - * @param {!jspb.BinaryWriter} writer - */ -proto.NewServerFailureMessage.prototype.serializeBinaryToWriter = function (writer) { - var f = undefined; - f = this.getId(); - if (f !== 0) { - writer.writeUint64( - 1, - f - ); - } - f = this.getMessage(); - if (f.length > 0) { - writer.writeString( - 2, - f - ); - } -}; - - -/** - * Creates a deep clone of this proto. No data is shared with the original. - * @return {!proto.NewServerFailureMessage} The clone. - */ -proto.NewServerFailureMessage.prototype.cloneMessage = function() { - return /** @type {!proto.NewServerFailureMessage} */ (jspb.Message.cloneMessage(this)); -}; - - -/** - * optional uint64 id = 1; - * @return {number} - */ -proto.NewServerFailureMessage.prototype.getId = function() { - return /** @type {number} */ (jspb.Message.getFieldProto3(this, 1, 0)); -}; - - -/** @param {number} value */ -proto.NewServerFailureMessage.prototype.setId = function(value) { - jspb.Message.setField(this, 1, value); -}; - - -/** - * optional string message = 2; - * @return {string} - */ -proto.NewServerFailureMessage.prototype.getMessage = function() { - return /** @type {string} */ (jspb.Message.getFieldProto3(this, 2, "")); -}; - - -/** @param {string} value */ -proto.NewServerFailureMessage.prototype.setMessage = function(value) { - jspb.Message.setField(this, 2, value); -}; - - - -/** - * Generated by JsPbCodeGenerator. - * @param {Array=} opt_data Optional initial data array, typically from a - * server response, or constructed directly in Javascript. The array is used - * in place and becomes part of the constructed object. It is not cloned. - * If no data is provided, the constructed object will be empty, but still - * valid. - * @extends {jspb.Message} - * @constructor - */ -proto.ServerEstablishedMessage = function(opt_data) { - jspb.Message.initialize(this, opt_data, 0, -1, null, null); -}; -goog.inherits(proto.ServerEstablishedMessage, jspb.Message); -if (goog.DEBUG && !COMPILED) { - proto.ServerEstablishedMessage.displayName = 'proto.ServerEstablishedMessage'; -} - - -if (jspb.Message.GENERATE_TO_OBJECT) { -/** - * Creates an object representation of this proto suitable for use in Soy templates. - * Field names that are reserved in JavaScript and will be renamed to pb_name. - * To access a reserved field use, foo.pb_, eg, foo.pb_default. - * For the list of reserved names please see: - * com.google.apps.jspb.JsClassTemplate.JS_RESERVED_WORDS. - * @param {boolean=} opt_includeInstance Whether to include the JSPB instance - * for transitional soy proto support: http://goto/soy-param-migration - * @return {!Object} - */ -proto.ServerEstablishedMessage.prototype.toObject = function(opt_includeInstance) { - return proto.ServerEstablishedMessage.toObject(opt_includeInstance, this); -}; - - -/** - * Static version of the {@see toObject} method. - * @param {boolean|undefined} includeInstance Whether to include the JSPB - * instance for transitional soy proto support: - * http://goto/soy-param-migration - * @param {!proto.ServerEstablishedMessage} msg The msg instance to transform. - * @return {!Object} - */ -proto.ServerEstablishedMessage.toObject = function(includeInstance, msg) { - var f, obj = { - id: msg.getId() - }; - - if (includeInstance) { - obj.$jspbMessageInstance = msg; - } - return obj; -}; -} - - -/** - * Deserializes binary data (in protobuf wire format). - * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.ServerEstablishedMessage} - */ -proto.ServerEstablishedMessage.deserializeBinary = function(bytes) { - var reader = new jspb.BinaryReader(bytes); - var msg = new proto.ServerEstablishedMessage; - return proto.ServerEstablishedMessage.deserializeBinaryFromReader(msg, reader); -}; - - -/** - * Deserializes binary data (in protobuf wire format) from the - * given reader into the given message object. - * @param {!proto.ServerEstablishedMessage} msg The message object to deserialize into. - * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.ServerEstablishedMessage} - */ -proto.ServerEstablishedMessage.deserializeBinaryFromReader = function(msg, reader) { - while (reader.nextField()) { - if (reader.isEndGroup()) { - break; - } - var field = reader.getFieldNumber(); - switch (field) { - case 1: - var value = /** @type {number} */ (reader.readUint64()); - msg.setId(value); - break; - default: - reader.skipField(); - break; - } - } - return msg; -}; - - -/** - * Class method variant: serializes the given message to binary data - * (in protobuf wire format), writing to the given BinaryWriter. - * @param {!proto.ServerEstablishedMessage} message - * @param {!jspb.BinaryWriter} writer - */ -proto.ServerEstablishedMessage.serializeBinaryToWriter = function(message, writer) { - message.serializeBinaryToWriter(writer); -}; - - -/** - * Serializes the message to binary data (in protobuf wire format). - * @return {!Uint8Array} - */ -proto.ServerEstablishedMessage.prototype.serializeBinary = function() { - var writer = new jspb.BinaryWriter(); - this.serializeBinaryToWriter(writer); - return writer.getResultBuffer(); -}; - - -/** - * Serializes the message to binary data (in protobuf wire format), - * writing to the given BinaryWriter. - * @param {!jspb.BinaryWriter} writer - */ -proto.ServerEstablishedMessage.prototype.serializeBinaryToWriter = function (writer) { - var f = undefined; - f = this.getId(); - if (f !== 0) { - writer.writeUint64( - 1, - f - ); - } -}; - - -/** - * Creates a deep clone of this proto. No data is shared with the original. - * @return {!proto.ServerEstablishedMessage} The clone. - */ -proto.ServerEstablishedMessage.prototype.cloneMessage = function() { - return /** @type {!proto.ServerEstablishedMessage} */ (jspb.Message.cloneMessage(this)); -}; - - -/** - * optional uint64 id = 1; - * @return {number} - */ -proto.ServerEstablishedMessage.prototype.getId = function() { - return /** @type {number} */ (jspb.Message.getFieldProto3(this, 1, 0)); -}; - - -/** @param {number} value */ -proto.ServerEstablishedMessage.prototype.setId = function(value) { - jspb.Message.setField(this, 1, value); -}; - - - -/** - * Generated by JsPbCodeGenerator. - * @param {Array=} opt_data Optional initial data array, typically from a - * server response, or constructed directly in Javascript. The array is used - * in place and becomes part of the constructed object. It is not cloned. - * If no data is provided, the constructed object will be empty, but still - * valid. - * @extends {jspb.Message} - * @constructor - */ -proto.ServerCloseMessage = function(opt_data) { - jspb.Message.initialize(this, opt_data, 0, -1, null, null); -}; -goog.inherits(proto.ServerCloseMessage, jspb.Message); -if (goog.DEBUG && !COMPILED) { - proto.ServerCloseMessage.displayName = 'proto.ServerCloseMessage'; -} - - -if (jspb.Message.GENERATE_TO_OBJECT) { -/** - * Creates an object representation of this proto suitable for use in Soy templates. - * Field names that are reserved in JavaScript and will be renamed to pb_name. - * To access a reserved field use, foo.pb_, eg, foo.pb_default. - * For the list of reserved names please see: - * com.google.apps.jspb.JsClassTemplate.JS_RESERVED_WORDS. - * @param {boolean=} opt_includeInstance Whether to include the JSPB instance - * for transitional soy proto support: http://goto/soy-param-migration - * @return {!Object} - */ -proto.ServerCloseMessage.prototype.toObject = function(opt_includeInstance) { - return proto.ServerCloseMessage.toObject(opt_includeInstance, this); -}; - - -/** - * Static version of the {@see toObject} method. - * @param {boolean|undefined} includeInstance Whether to include the JSPB - * instance for transitional soy proto support: - * http://goto/soy-param-migration - * @param {!proto.ServerCloseMessage} msg The msg instance to transform. - * @return {!Object} - */ -proto.ServerCloseMessage.toObject = function(includeInstance, msg) { - var f, obj = { - id: msg.getId(), - reason: msg.getReason() - }; - - if (includeInstance) { - obj.$jspbMessageInstance = msg; - } - return obj; -}; -} - - -/** - * Deserializes binary data (in protobuf wire format). - * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.ServerCloseMessage} - */ -proto.ServerCloseMessage.deserializeBinary = function(bytes) { - var reader = new jspb.BinaryReader(bytes); - var msg = new proto.ServerCloseMessage; - return proto.ServerCloseMessage.deserializeBinaryFromReader(msg, reader); -}; - - -/** - * Deserializes binary data (in protobuf wire format) from the - * given reader into the given message object. - * @param {!proto.ServerCloseMessage} msg The message object to deserialize into. - * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.ServerCloseMessage} - */ -proto.ServerCloseMessage.deserializeBinaryFromReader = function(msg, reader) { - while (reader.nextField()) { - if (reader.isEndGroup()) { - break; - } - var field = reader.getFieldNumber(); - switch (field) { - case 1: - var value = /** @type {number} */ (reader.readUint64()); - msg.setId(value); - break; - case 2: - var value = /** @type {string} */ (reader.readString()); - msg.setReason(value); - break; - default: - reader.skipField(); - break; - } - } - return msg; -}; - - -/** - * Class method variant: serializes the given message to binary data - * (in protobuf wire format), writing to the given BinaryWriter. - * @param {!proto.ServerCloseMessage} message - * @param {!jspb.BinaryWriter} writer - */ -proto.ServerCloseMessage.serializeBinaryToWriter = function(message, writer) { - message.serializeBinaryToWriter(writer); -}; - - -/** - * Serializes the message to binary data (in protobuf wire format). - * @return {!Uint8Array} - */ -proto.ServerCloseMessage.prototype.serializeBinary = function() { - var writer = new jspb.BinaryWriter(); - this.serializeBinaryToWriter(writer); - return writer.getResultBuffer(); -}; - - -/** - * Serializes the message to binary data (in protobuf wire format), - * writing to the given BinaryWriter. - * @param {!jspb.BinaryWriter} writer - */ -proto.ServerCloseMessage.prototype.serializeBinaryToWriter = function (writer) { - var f = undefined; - f = this.getId(); - if (f !== 0) { - writer.writeUint64( - 1, - f - ); - } - f = this.getReason(); - if (f.length > 0) { - writer.writeString( - 2, - f - ); - } -}; - - -/** - * Creates a deep clone of this proto. No data is shared with the original. - * @return {!proto.ServerCloseMessage} The clone. - */ -proto.ServerCloseMessage.prototype.cloneMessage = function() { - return /** @type {!proto.ServerCloseMessage} */ (jspb.Message.cloneMessage(this)); -}; - - -/** - * optional uint64 id = 1; - * @return {number} - */ -proto.ServerCloseMessage.prototype.getId = function() { - return /** @type {number} */ (jspb.Message.getFieldProto3(this, 1, 0)); -}; - - -/** @param {number} value */ -proto.ServerCloseMessage.prototype.setId = function(value) { - jspb.Message.setField(this, 1, value); -}; - - -/** - * optional string reason = 2; - * @return {string} - */ -proto.ServerCloseMessage.prototype.getReason = function() { - return /** @type {string} */ (jspb.Message.getFieldProto3(this, 2, "")); -}; - - -/** @param {string} value */ -proto.ServerCloseMessage.prototype.setReason = function(value) { - jspb.Message.setField(this, 2, value); -}; - - - -/** - * Generated by JsPbCodeGenerator. - * @param {Array=} opt_data Optional initial data array, typically from a - * server response, or constructed directly in Javascript. The array is used - * in place and becomes part of the constructed object. It is not cloned. - * If no data is provided, the constructed object will be empty, but still - * valid. - * @extends {jspb.Message} - * @constructor - */ -proto.ServerConnectionEstablishedMessage = function(opt_data) { - jspb.Message.initialize(this, opt_data, 0, -1, null, null); -}; -goog.inherits(proto.ServerConnectionEstablishedMessage, jspb.Message); -if (goog.DEBUG && !COMPILED) { - proto.ServerConnectionEstablishedMessage.displayName = 'proto.ServerConnectionEstablishedMessage'; -} - - -if (jspb.Message.GENERATE_TO_OBJECT) { -/** - * Creates an object representation of this proto suitable for use in Soy templates. - * Field names that are reserved in JavaScript and will be renamed to pb_name. - * To access a reserved field use, foo.pb_, eg, foo.pb_default. - * For the list of reserved names please see: - * com.google.apps.jspb.JsClassTemplate.JS_RESERVED_WORDS. - * @param {boolean=} opt_includeInstance Whether to include the JSPB instance - * for transitional soy proto support: http://goto/soy-param-migration - * @return {!Object} - */ -proto.ServerConnectionEstablishedMessage.prototype.toObject = function(opt_includeInstance) { - return proto.ServerConnectionEstablishedMessage.toObject(opt_includeInstance, this); -}; - - -/** - * Static version of the {@see toObject} method. - * @param {boolean|undefined} includeInstance Whether to include the JSPB - * instance for transitional soy proto support: - * http://goto/soy-param-migration - * @param {!proto.ServerConnectionEstablishedMessage} msg The msg instance to transform. - * @return {!Object} - */ -proto.ServerConnectionEstablishedMessage.toObject = function(includeInstance, msg) { - var f, obj = { - serverId: msg.getServerId(), - connectionId: msg.getConnectionId() - }; - - if (includeInstance) { - obj.$jspbMessageInstance = msg; - } - return obj; -}; -} - - -/** - * Deserializes binary data (in protobuf wire format). - * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.ServerConnectionEstablishedMessage} - */ -proto.ServerConnectionEstablishedMessage.deserializeBinary = function(bytes) { - var reader = new jspb.BinaryReader(bytes); - var msg = new proto.ServerConnectionEstablishedMessage; - return proto.ServerConnectionEstablishedMessage.deserializeBinaryFromReader(msg, reader); -}; - - -/** - * Deserializes binary data (in protobuf wire format) from the - * given reader into the given message object. - * @param {!proto.ServerConnectionEstablishedMessage} msg The message object to deserialize into. - * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.ServerConnectionEstablishedMessage} - */ -proto.ServerConnectionEstablishedMessage.deserializeBinaryFromReader = function(msg, reader) { - while (reader.nextField()) { - if (reader.isEndGroup()) { - break; - } - var field = reader.getFieldNumber(); - switch (field) { - case 1: - var value = /** @type {number} */ (reader.readUint64()); - msg.setServerId(value); - break; - case 2: - var value = /** @type {number} */ (reader.readUint64()); - msg.setConnectionId(value); - break; - default: - reader.skipField(); - break; - } - } - return msg; -}; - - -/** - * Class method variant: serializes the given message to binary data - * (in protobuf wire format), writing to the given BinaryWriter. - * @param {!proto.ServerConnectionEstablishedMessage} message - * @param {!jspb.BinaryWriter} writer - */ -proto.ServerConnectionEstablishedMessage.serializeBinaryToWriter = function(message, writer) { - message.serializeBinaryToWriter(writer); -}; - - -/** - * Serializes the message to binary data (in protobuf wire format). - * @return {!Uint8Array} - */ -proto.ServerConnectionEstablishedMessage.prototype.serializeBinary = function() { - var writer = new jspb.BinaryWriter(); - this.serializeBinaryToWriter(writer); - return writer.getResultBuffer(); -}; - - -/** - * Serializes the message to binary data (in protobuf wire format), - * writing to the given BinaryWriter. - * @param {!jspb.BinaryWriter} writer - */ -proto.ServerConnectionEstablishedMessage.prototype.serializeBinaryToWriter = function (writer) { - var f = undefined; - f = this.getServerId(); - if (f !== 0) { - writer.writeUint64( - 1, - f - ); - } - f = this.getConnectionId(); - if (f !== 0) { - writer.writeUint64( - 2, - f - ); - } -}; - - -/** - * Creates a deep clone of this proto. No data is shared with the original. - * @return {!proto.ServerConnectionEstablishedMessage} The clone. - */ -proto.ServerConnectionEstablishedMessage.prototype.cloneMessage = function() { - return /** @type {!proto.ServerConnectionEstablishedMessage} */ (jspb.Message.cloneMessage(this)); -}; - - -/** - * optional uint64 server_id = 1; - * @return {number} - */ -proto.ServerConnectionEstablishedMessage.prototype.getServerId = function() { - return /** @type {number} */ (jspb.Message.getFieldProto3(this, 1, 0)); -}; - - -/** @param {number} value */ -proto.ServerConnectionEstablishedMessage.prototype.setServerId = function(value) { - jspb.Message.setField(this, 1, value); -}; - - -/** - * optional uint64 connection_id = 2; - * @return {number} - */ -proto.ServerConnectionEstablishedMessage.prototype.getConnectionId = function() { - return /** @type {number} */ (jspb.Message.getFieldProto3(this, 2, 0)); -}; - - -/** @param {number} value */ -proto.ServerConnectionEstablishedMessage.prototype.setConnectionId = function(value) { - jspb.Message.setField(this, 2, value); -}; - - -goog.object.extend(exports, proto); diff --git a/packages/protocol/src/proto/index.ts b/packages/protocol/src/proto/index.ts index 12ee74852..c46ab604d 100644 --- a/packages/protocol/src/proto/index.ts +++ b/packages/protocol/src/proto/index.ts @@ -1,4 +1,3 @@ export * from "./client_pb"; -export * from "./command_pb"; export * from "./node_pb"; export * from "./vscode_pb"; diff --git a/packages/protocol/src/proto/node.proto b/packages/protocol/src/proto/node.proto index d305dc3ce..7af94becb 100644 --- a/packages/protocol/src/proto/node.proto +++ b/packages/protocol/src/proto/node.proto @@ -1,16 +1,5 @@ syntax = "proto3"; -message TypedValue { - enum Type { - String = 0; - Number = 1; - Object = 2; - Boolean = 3; - } - Type type = 1; - string value = 2; -} - message NewEvalMessage { uint64 id = 1; string function = 2; @@ -41,5 +30,5 @@ message EvalFailedMessage { message EvalDoneMessage { uint64 id = 1; - TypedValue response = 2; + string response = 2; } diff --git a/packages/protocol/src/proto/node_pb.d.ts b/packages/protocol/src/proto/node_pb.d.ts index ef4052a74..3edcd2357 100644 --- a/packages/protocol/src/proto/node_pb.d.ts +++ b/packages/protocol/src/proto/node_pb.d.ts @@ -3,37 +3,6 @@ import * as jspb from "google-protobuf"; -export class TypedValue extends jspb.Message { - getType(): TypedValue.Type; - setType(value: TypedValue.Type): void; - - getValue(): string; - setValue(value: string): void; - - serializeBinary(): Uint8Array; - toObject(includeInstance?: boolean): TypedValue.AsObject; - static toObject(includeInstance: boolean, msg: TypedValue): TypedValue.AsObject; - static extensions: {[key: number]: jspb.ExtensionFieldInfo}; - static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo}; - static serializeBinaryToWriter(message: TypedValue, writer: jspb.BinaryWriter): void; - static deserializeBinary(bytes: Uint8Array): TypedValue; - static deserializeBinaryFromReader(message: TypedValue, reader: jspb.BinaryReader): TypedValue; -} - -export namespace TypedValue { - export type AsObject = { - type: TypedValue.Type, - value: string, - } - - export enum Type { - STRING = 0, - NUMBER = 1, - OBJECT = 2, - BOOLEAN = 3, - } -} - export class NewEvalMessage extends jspb.Message { getId(): number; setId(value: number): void; @@ -140,10 +109,8 @@ export class EvalDoneMessage extends jspb.Message { getId(): number; setId(value: number): void; - hasResponse(): boolean; - clearResponse(): void; - getResponse(): TypedValue | undefined; - setResponse(value?: TypedValue): void; + getResponse(): string; + setResponse(value: string): void; serializeBinary(): Uint8Array; toObject(includeInstance?: boolean): EvalDoneMessage.AsObject; @@ -158,7 +125,7 @@ export class EvalDoneMessage extends jspb.Message { export namespace EvalDoneMessage { export type AsObject = { id: number, - response?: TypedValue.AsObject, + response: string, } } diff --git a/packages/protocol/src/proto/node_pb.js b/packages/protocol/src/proto/node_pb.js index e15bbef09..ce4ccbe60 100644 --- a/packages/protocol/src/proto/node_pb.js +++ b/packages/protocol/src/proto/node_pb.js @@ -1,6 +1,8 @@ /** * @fileoverview * @enhanceable + * @suppress {messageConventions} JS Compiler reports an error if a variable or + * field starts with 'MSG_' and isn't a translatable message. * @public */ // GENERATED CODE -- DO NOT EDIT! @@ -14,204 +16,6 @@ goog.exportSymbol('proto.EvalEventMessage', null, global); goog.exportSymbol('proto.EvalFailedMessage', null, global); goog.exportSymbol('proto.EvalFailedMessage.Reason', null, global); goog.exportSymbol('proto.NewEvalMessage', null, global); -goog.exportSymbol('proto.TypedValue', null, global); -goog.exportSymbol('proto.TypedValue.Type', null, global); - -/** - * Generated by JsPbCodeGenerator. - * @param {Array=} opt_data Optional initial data array, typically from a - * server response, or constructed directly in Javascript. The array is used - * in place and becomes part of the constructed object. It is not cloned. - * If no data is provided, the constructed object will be empty, but still - * valid. - * @extends {jspb.Message} - * @constructor - */ -proto.TypedValue = function(opt_data) { - jspb.Message.initialize(this, opt_data, 0, -1, null, null); -}; -goog.inherits(proto.TypedValue, jspb.Message); -if (goog.DEBUG && !COMPILED) { - proto.TypedValue.displayName = 'proto.TypedValue'; -} - - -if (jspb.Message.GENERATE_TO_OBJECT) { -/** - * Creates an object representation of this proto suitable for use in Soy templates. - * Field names that are reserved in JavaScript and will be renamed to pb_name. - * To access a reserved field use, foo.pb_, eg, foo.pb_default. - * For the list of reserved names please see: - * com.google.apps.jspb.JsClassTemplate.JS_RESERVED_WORDS. - * @param {boolean=} opt_includeInstance Whether to include the JSPB instance - * for transitional soy proto support: http://goto/soy-param-migration - * @return {!Object} - */ -proto.TypedValue.prototype.toObject = function(opt_includeInstance) { - return proto.TypedValue.toObject(opt_includeInstance, this); -}; - - -/** - * Static version of the {@see toObject} method. - * @param {boolean|undefined} includeInstance Whether to include the JSPB - * instance for transitional soy proto support: - * http://goto/soy-param-migration - * @param {!proto.TypedValue} msg The msg instance to transform. - * @return {!Object} - */ -proto.TypedValue.toObject = function(includeInstance, msg) { - var f, obj = { - type: msg.getType(), - value: msg.getValue() - }; - - if (includeInstance) { - obj.$jspbMessageInstance = msg; - } - return obj; -}; -} - - -/** - * Deserializes binary data (in protobuf wire format). - * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.TypedValue} - */ -proto.TypedValue.deserializeBinary = function(bytes) { - var reader = new jspb.BinaryReader(bytes); - var msg = new proto.TypedValue; - return proto.TypedValue.deserializeBinaryFromReader(msg, reader); -}; - - -/** - * Deserializes binary data (in protobuf wire format) from the - * given reader into the given message object. - * @param {!proto.TypedValue} msg The message object to deserialize into. - * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.TypedValue} - */ -proto.TypedValue.deserializeBinaryFromReader = function(msg, reader) { - while (reader.nextField()) { - if (reader.isEndGroup()) { - break; - } - var field = reader.getFieldNumber(); - switch (field) { - case 1: - var value = /** @type {!proto.TypedValue.Type} */ (reader.readEnum()); - msg.setType(value); - break; - case 2: - var value = /** @type {string} */ (reader.readString()); - msg.setValue(value); - break; - default: - reader.skipField(); - break; - } - } - return msg; -}; - - -/** - * Class method variant: serializes the given message to binary data - * (in protobuf wire format), writing to the given BinaryWriter. - * @param {!proto.TypedValue} message - * @param {!jspb.BinaryWriter} writer - */ -proto.TypedValue.serializeBinaryToWriter = function(message, writer) { - message.serializeBinaryToWriter(writer); -}; - - -/** - * Serializes the message to binary data (in protobuf wire format). - * @return {!Uint8Array} - */ -proto.TypedValue.prototype.serializeBinary = function() { - var writer = new jspb.BinaryWriter(); - this.serializeBinaryToWriter(writer); - return writer.getResultBuffer(); -}; - - -/** - * Serializes the message to binary data (in protobuf wire format), - * writing to the given BinaryWriter. - * @param {!jspb.BinaryWriter} writer - */ -proto.TypedValue.prototype.serializeBinaryToWriter = function (writer) { - var f = undefined; - f = this.getType(); - if (f !== 0.0) { - writer.writeEnum( - 1, - f - ); - } - f = this.getValue(); - if (f.length > 0) { - writer.writeString( - 2, - f - ); - } -}; - - -/** - * Creates a deep clone of this proto. No data is shared with the original. - * @return {!proto.TypedValue} The clone. - */ -proto.TypedValue.prototype.cloneMessage = function() { - return /** @type {!proto.TypedValue} */ (jspb.Message.cloneMessage(this)); -}; - - -/** - * optional Type type = 1; - * @return {!proto.TypedValue.Type} - */ -proto.TypedValue.prototype.getType = function() { - return /** @type {!proto.TypedValue.Type} */ (jspb.Message.getFieldProto3(this, 1, 0)); -}; - - -/** @param {!proto.TypedValue.Type} value */ -proto.TypedValue.prototype.setType = function(value) { - jspb.Message.setField(this, 1, value); -}; - - -/** - * optional string value = 2; - * @return {string} - */ -proto.TypedValue.prototype.getValue = function() { - return /** @type {string} */ (jspb.Message.getFieldProto3(this, 2, "")); -}; - - -/** @param {string} value */ -proto.TypedValue.prototype.setValue = function(value) { - jspb.Message.setField(this, 2, value); -}; - - -/** - * @enum {number} - */ -proto.TypedValue.Type = { - STRING: 0, - NUMBER: 1, - OBJECT: 2, - BOOLEAN: 3 -}; - /** * Generated by JsPbCodeGenerator. @@ -262,14 +66,15 @@ proto.NewEvalMessage.prototype.toObject = function(opt_includeInstance) { * http://goto/soy-param-migration * @param {!proto.NewEvalMessage} msg The msg instance to transform. * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages */ proto.NewEvalMessage.toObject = function(includeInstance, msg) { var f, obj = { - id: msg.getId(), - pb_function: msg.getFunction(), - argsList: jspb.Message.getField(msg, 3), - timeout: msg.getTimeout(), - active: msg.getActive() + id: jspb.Message.getFieldWithDefault(msg, 1, 0), + pb_function: jspb.Message.getFieldWithDefault(msg, 2, ""), + argsList: jspb.Message.getRepeatedField(msg, 3), + timeout: jspb.Message.getFieldWithDefault(msg, 4, 0), + active: jspb.Message.getFieldWithDefault(msg, 5, false) }; if (includeInstance) { @@ -316,8 +121,7 @@ proto.NewEvalMessage.deserializeBinaryFromReader = function(msg, reader) { break; case 3: var value = /** @type {string} */ (reader.readString()); - msg.getArgsList().push(value); - msg.setArgsList(msg.getArgsList()); + msg.addArgs(value); break; case 4: var value = /** @type {number} */ (reader.readUint32()); @@ -336,64 +140,55 @@ proto.NewEvalMessage.deserializeBinaryFromReader = function(msg, reader) { }; -/** - * Class method variant: serializes the given message to binary data - * (in protobuf wire format), writing to the given BinaryWriter. - * @param {!proto.NewEvalMessage} message - * @param {!jspb.BinaryWriter} writer - */ -proto.NewEvalMessage.serializeBinaryToWriter = function(message, writer) { - message.serializeBinaryToWriter(writer); -}; - - /** * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ proto.NewEvalMessage.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - this.serializeBinaryToWriter(writer); + proto.NewEvalMessage.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; /** - * Serializes the message to binary data (in protobuf wire format), - * writing to the given BinaryWriter. + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.NewEvalMessage} message * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.NewEvalMessage.prototype.serializeBinaryToWriter = function (writer) { +proto.NewEvalMessage.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = this.getId(); + f = message.getId(); if (f !== 0) { writer.writeUint64( 1, f ); } - f = this.getFunction(); + f = message.getFunction(); if (f.length > 0) { writer.writeString( 2, f ); } - f = this.getArgsList(); + f = message.getArgsList(); if (f.length > 0) { writer.writeRepeatedString( 3, f ); } - f = this.getTimeout(); + f = message.getTimeout(); if (f !== 0) { writer.writeUint32( 4, f ); } - f = this.getActive(); + f = message.getActive(); if (f) { writer.writeBool( 5, @@ -403,27 +198,18 @@ proto.NewEvalMessage.prototype.serializeBinaryToWriter = function (writer) { }; -/** - * Creates a deep clone of this proto. No data is shared with the original. - * @return {!proto.NewEvalMessage} The clone. - */ -proto.NewEvalMessage.prototype.cloneMessage = function() { - return /** @type {!proto.NewEvalMessage} */ (jspb.Message.cloneMessage(this)); -}; - - /** * optional uint64 id = 1; * @return {number} */ proto.NewEvalMessage.prototype.getId = function() { - return /** @type {number} */ (jspb.Message.getFieldProto3(this, 1, 0)); + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 1, 0)); }; -/** @param {number} value */ +/** @param {number} value */ proto.NewEvalMessage.prototype.setId = function(value) { - jspb.Message.setField(this, 1, value); + jspb.Message.setProto3IntField(this, 1, value); }; @@ -432,35 +218,42 @@ proto.NewEvalMessage.prototype.setId = function(value) { * @return {string} */ proto.NewEvalMessage.prototype.getFunction = function() { - return /** @type {string} */ (jspb.Message.getFieldProto3(this, 2, "")); + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); }; -/** @param {string} value */ +/** @param {string} value */ proto.NewEvalMessage.prototype.setFunction = function(value) { - jspb.Message.setField(this, 2, value); + jspb.Message.setProto3StringField(this, 2, value); }; /** * repeated string args = 3; - * If you change this array by adding, removing or replacing elements, or if you - * replace the array itself, then you must call the setter to update it. - * @return {!Array.} + * @return {!Array} */ proto.NewEvalMessage.prototype.getArgsList = function() { - return /** @type {!Array.} */ (jspb.Message.getField(this, 3)); + return /** @type {!Array} */ (jspb.Message.getRepeatedField(this, 3)); }; -/** @param {Array.} value */ +/** @param {!Array} value */ proto.NewEvalMessage.prototype.setArgsList = function(value) { jspb.Message.setField(this, 3, value || []); }; +/** + * @param {!string} value + * @param {number=} opt_index + */ +proto.NewEvalMessage.prototype.addArgs = function(value, opt_index) { + jspb.Message.addToRepeatedField(this, 3, value, opt_index); +}; + + proto.NewEvalMessage.prototype.clearArgsList = function() { - jspb.Message.setField(this, 3, []); + this.setArgsList([]); }; @@ -469,13 +262,13 @@ proto.NewEvalMessage.prototype.clearArgsList = function() { * @return {number} */ proto.NewEvalMessage.prototype.getTimeout = function() { - return /** @type {number} */ (jspb.Message.getFieldProto3(this, 4, 0)); + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 4, 0)); }; -/** @param {number} value */ +/** @param {number} value */ proto.NewEvalMessage.prototype.setTimeout = function(value) { - jspb.Message.setField(this, 4, value); + jspb.Message.setProto3IntField(this, 4, value); }; @@ -486,13 +279,13 @@ proto.NewEvalMessage.prototype.setTimeout = function(value) { * @return {boolean} */ proto.NewEvalMessage.prototype.getActive = function() { - return /** @type {boolean} */ (jspb.Message.getFieldProto3(this, 5, false)); + return /** @type {boolean} */ (jspb.Message.getFieldWithDefault(this, 5, false)); }; -/** @param {boolean} value */ +/** @param {boolean} value */ proto.NewEvalMessage.prototype.setActive = function(value) { - jspb.Message.setField(this, 5, value); + jspb.Message.setProto3BooleanField(this, 5, value); }; @@ -546,12 +339,13 @@ proto.EvalEventMessage.prototype.toObject = function(opt_includeInstance) { * http://goto/soy-param-migration * @param {!proto.EvalEventMessage} msg The msg instance to transform. * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages */ proto.EvalEventMessage.toObject = function(includeInstance, msg) { var f, obj = { - id: msg.getId(), - event: msg.getEvent(), - argsList: jspb.Message.getField(msg, 3) + id: jspb.Message.getFieldWithDefault(msg, 1, 0), + event: jspb.Message.getFieldWithDefault(msg, 2, ""), + argsList: jspb.Message.getRepeatedField(msg, 3) }; if (includeInstance) { @@ -598,8 +392,7 @@ proto.EvalEventMessage.deserializeBinaryFromReader = function(msg, reader) { break; case 3: var value = /** @type {string} */ (reader.readString()); - msg.getArgsList().push(value); - msg.setArgsList(msg.getArgsList()); + msg.addArgs(value); break; default: reader.skipField(); @@ -610,50 +403,41 @@ proto.EvalEventMessage.deserializeBinaryFromReader = function(msg, reader) { }; -/** - * Class method variant: serializes the given message to binary data - * (in protobuf wire format), writing to the given BinaryWriter. - * @param {!proto.EvalEventMessage} message - * @param {!jspb.BinaryWriter} writer - */ -proto.EvalEventMessage.serializeBinaryToWriter = function(message, writer) { - message.serializeBinaryToWriter(writer); -}; - - /** * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ proto.EvalEventMessage.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - this.serializeBinaryToWriter(writer); + proto.EvalEventMessage.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; /** - * Serializes the message to binary data (in protobuf wire format), - * writing to the given BinaryWriter. + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.EvalEventMessage} message * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.EvalEventMessage.prototype.serializeBinaryToWriter = function (writer) { +proto.EvalEventMessage.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = this.getId(); + f = message.getId(); if (f !== 0) { writer.writeUint64( 1, f ); } - f = this.getEvent(); + f = message.getEvent(); if (f.length > 0) { writer.writeString( 2, f ); } - f = this.getArgsList(); + f = message.getArgsList(); if (f.length > 0) { writer.writeRepeatedString( 3, @@ -663,27 +447,18 @@ proto.EvalEventMessage.prototype.serializeBinaryToWriter = function (writer) { }; -/** - * Creates a deep clone of this proto. No data is shared with the original. - * @return {!proto.EvalEventMessage} The clone. - */ -proto.EvalEventMessage.prototype.cloneMessage = function() { - return /** @type {!proto.EvalEventMessage} */ (jspb.Message.cloneMessage(this)); -}; - - /** * optional uint64 id = 1; * @return {number} */ proto.EvalEventMessage.prototype.getId = function() { - return /** @type {number} */ (jspb.Message.getFieldProto3(this, 1, 0)); + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 1, 0)); }; -/** @param {number} value */ +/** @param {number} value */ proto.EvalEventMessage.prototype.setId = function(value) { - jspb.Message.setField(this, 1, value); + jspb.Message.setProto3IntField(this, 1, value); }; @@ -692,35 +467,42 @@ proto.EvalEventMessage.prototype.setId = function(value) { * @return {string} */ proto.EvalEventMessage.prototype.getEvent = function() { - return /** @type {string} */ (jspb.Message.getFieldProto3(this, 2, "")); + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); }; -/** @param {string} value */ +/** @param {string} value */ proto.EvalEventMessage.prototype.setEvent = function(value) { - jspb.Message.setField(this, 2, value); + jspb.Message.setProto3StringField(this, 2, value); }; /** * repeated string args = 3; - * If you change this array by adding, removing or replacing elements, or if you - * replace the array itself, then you must call the setter to update it. - * @return {!Array.} + * @return {!Array} */ proto.EvalEventMessage.prototype.getArgsList = function() { - return /** @type {!Array.} */ (jspb.Message.getField(this, 3)); + return /** @type {!Array} */ (jspb.Message.getRepeatedField(this, 3)); }; -/** @param {Array.} value */ +/** @param {!Array} value */ proto.EvalEventMessage.prototype.setArgsList = function(value) { jspb.Message.setField(this, 3, value || []); }; +/** + * @param {!string} value + * @param {number=} opt_index + */ +proto.EvalEventMessage.prototype.addArgs = function(value, opt_index) { + jspb.Message.addToRepeatedField(this, 3, value, opt_index); +}; + + proto.EvalEventMessage.prototype.clearArgsList = function() { - jspb.Message.setField(this, 3, []); + this.setArgsList([]); }; @@ -767,12 +549,13 @@ proto.EvalFailedMessage.prototype.toObject = function(opt_includeInstance) { * http://goto/soy-param-migration * @param {!proto.EvalFailedMessage} msg The msg instance to transform. * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages */ proto.EvalFailedMessage.toObject = function(includeInstance, msg) { var f, obj = { - id: msg.getId(), - reason: msg.getReason(), - message: msg.getMessage() + id: jspb.Message.getFieldWithDefault(msg, 1, 0), + reason: jspb.Message.getFieldWithDefault(msg, 2, 0), + message: jspb.Message.getFieldWithDefault(msg, 3, "") }; if (includeInstance) { @@ -830,50 +613,41 @@ proto.EvalFailedMessage.deserializeBinaryFromReader = function(msg, reader) { }; -/** - * Class method variant: serializes the given message to binary data - * (in protobuf wire format), writing to the given BinaryWriter. - * @param {!proto.EvalFailedMessage} message - * @param {!jspb.BinaryWriter} writer - */ -proto.EvalFailedMessage.serializeBinaryToWriter = function(message, writer) { - message.serializeBinaryToWriter(writer); -}; - - /** * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ proto.EvalFailedMessage.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - this.serializeBinaryToWriter(writer); + proto.EvalFailedMessage.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; /** - * Serializes the message to binary data (in protobuf wire format), - * writing to the given BinaryWriter. + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.EvalFailedMessage} message * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.EvalFailedMessage.prototype.serializeBinaryToWriter = function (writer) { +proto.EvalFailedMessage.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = this.getId(); + f = message.getId(); if (f !== 0) { writer.writeUint64( 1, f ); } - f = this.getReason(); + f = message.getReason(); if (f !== 0.0) { writer.writeEnum( 2, f ); } - f = this.getMessage(); + f = message.getMessage(); if (f.length > 0) { writer.writeString( 3, @@ -883,60 +657,6 @@ proto.EvalFailedMessage.prototype.serializeBinaryToWriter = function (writer) { }; -/** - * Creates a deep clone of this proto. No data is shared with the original. - * @return {!proto.EvalFailedMessage} The clone. - */ -proto.EvalFailedMessage.prototype.cloneMessage = function() { - return /** @type {!proto.EvalFailedMessage} */ (jspb.Message.cloneMessage(this)); -}; - - -/** - * optional uint64 id = 1; - * @return {number} - */ -proto.EvalFailedMessage.prototype.getId = function() { - return /** @type {number} */ (jspb.Message.getFieldProto3(this, 1, 0)); -}; - - -/** @param {number} value */ -proto.EvalFailedMessage.prototype.setId = function(value) { - jspb.Message.setField(this, 1, value); -}; - - -/** - * optional Reason reason = 2; - * @return {!proto.EvalFailedMessage.Reason} - */ -proto.EvalFailedMessage.prototype.getReason = function() { - return /** @type {!proto.EvalFailedMessage.Reason} */ (jspb.Message.getFieldProto3(this, 2, 0)); -}; - - -/** @param {!proto.EvalFailedMessage.Reason} value */ -proto.EvalFailedMessage.prototype.setReason = function(value) { - jspb.Message.setField(this, 2, value); -}; - - -/** - * optional string message = 3; - * @return {string} - */ -proto.EvalFailedMessage.prototype.getMessage = function() { - return /** @type {string} */ (jspb.Message.getFieldProto3(this, 3, "")); -}; - - -/** @param {string} value */ -proto.EvalFailedMessage.prototype.setMessage = function(value) { - jspb.Message.setField(this, 3, value); -}; - - /** * @enum {number} */ @@ -946,6 +666,51 @@ proto.EvalFailedMessage.Reason = { CONFLICT: 2 }; +/** + * optional uint64 id = 1; + * @return {number} + */ +proto.EvalFailedMessage.prototype.getId = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 1, 0)); +}; + + +/** @param {number} value */ +proto.EvalFailedMessage.prototype.setId = function(value) { + jspb.Message.setProto3IntField(this, 1, value); +}; + + +/** + * optional Reason reason = 2; + * @return {!proto.EvalFailedMessage.Reason} + */ +proto.EvalFailedMessage.prototype.getReason = function() { + return /** @type {!proto.EvalFailedMessage.Reason} */ (jspb.Message.getFieldWithDefault(this, 2, 0)); +}; + + +/** @param {!proto.EvalFailedMessage.Reason} value */ +proto.EvalFailedMessage.prototype.setReason = function(value) { + jspb.Message.setProto3EnumField(this, 2, value); +}; + + +/** + * optional string message = 3; + * @return {string} + */ +proto.EvalFailedMessage.prototype.getMessage = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, "")); +}; + + +/** @param {string} value */ +proto.EvalFailedMessage.prototype.setMessage = function(value) { + jspb.Message.setProto3StringField(this, 3, value); +}; + + /** * Generated by JsPbCodeGenerator. @@ -989,11 +754,12 @@ proto.EvalDoneMessage.prototype.toObject = function(opt_includeInstance) { * http://goto/soy-param-migration * @param {!proto.EvalDoneMessage} msg The msg instance to transform. * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages */ proto.EvalDoneMessage.toObject = function(includeInstance, msg) { var f, obj = { - id: msg.getId(), - response: (f = msg.getResponse()) && proto.TypedValue.toObject(includeInstance, f) + id: jspb.Message.getFieldWithDefault(msg, 1, 0), + response: jspb.Message.getFieldWithDefault(msg, 2, "") }; if (includeInstance) { @@ -1035,8 +801,7 @@ proto.EvalDoneMessage.deserializeBinaryFromReader = function(msg, reader) { msg.setId(value); break; case 2: - var value = new proto.TypedValue; - reader.readMessage(value,proto.TypedValue.deserializeBinaryFromReader); + var value = /** @type {string} */ (reader.readString()); msg.setResponse(value); break; default: @@ -1048,104 +813,70 @@ proto.EvalDoneMessage.deserializeBinaryFromReader = function(msg, reader) { }; -/** - * Class method variant: serializes the given message to binary data - * (in protobuf wire format), writing to the given BinaryWriter. - * @param {!proto.EvalDoneMessage} message - * @param {!jspb.BinaryWriter} writer - */ -proto.EvalDoneMessage.serializeBinaryToWriter = function(message, writer) { - message.serializeBinaryToWriter(writer); -}; - - /** * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ proto.EvalDoneMessage.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - this.serializeBinaryToWriter(writer); + proto.EvalDoneMessage.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; /** - * Serializes the message to binary data (in protobuf wire format), - * writing to the given BinaryWriter. + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.EvalDoneMessage} message * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.EvalDoneMessage.prototype.serializeBinaryToWriter = function (writer) { +proto.EvalDoneMessage.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = this.getId(); + f = message.getId(); if (f !== 0) { writer.writeUint64( 1, f ); } - f = this.getResponse(); - if (f != null) { - writer.writeMessage( + f = message.getResponse(); + if (f.length > 0) { + writer.writeString( 2, - f, - proto.TypedValue.serializeBinaryToWriter + f ); } }; -/** - * Creates a deep clone of this proto. No data is shared with the original. - * @return {!proto.EvalDoneMessage} The clone. - */ -proto.EvalDoneMessage.prototype.cloneMessage = function() { - return /** @type {!proto.EvalDoneMessage} */ (jspb.Message.cloneMessage(this)); -}; - - /** * optional uint64 id = 1; * @return {number} */ proto.EvalDoneMessage.prototype.getId = function() { - return /** @type {number} */ (jspb.Message.getFieldProto3(this, 1, 0)); + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 1, 0)); }; -/** @param {number} value */ +/** @param {number} value */ proto.EvalDoneMessage.prototype.setId = function(value) { - jspb.Message.setField(this, 1, value); + jspb.Message.setProto3IntField(this, 1, value); }; /** - * optional TypedValue response = 2; - * @return {proto.TypedValue} + * optional string response = 2; + * @return {string} */ proto.EvalDoneMessage.prototype.getResponse = function() { - return /** @type{proto.TypedValue} */ ( - jspb.Message.getWrapperField(this, proto.TypedValue, 2)); + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); }; -/** @param {proto.TypedValue|undefined} value */ +/** @param {string} value */ proto.EvalDoneMessage.prototype.setResponse = function(value) { - jspb.Message.setWrapperField(this, 2, value); -}; - - -proto.EvalDoneMessage.prototype.clearResponse = function() { - this.setResponse(undefined); -}; - - -/** - * Returns whether this field is set. - * @return{!boolean} - */ -proto.EvalDoneMessage.prototype.hasResponse = function() { - return jspb.Message.getField(this, 2) != null; + jspb.Message.setProto3StringField(this, 2, value); }; diff --git a/packages/protocol/src/proto/vscode_pb.js b/packages/protocol/src/proto/vscode_pb.js index f7bdf1863..07335a8fd 100644 --- a/packages/protocol/src/proto/vscode_pb.js +++ b/packages/protocol/src/proto/vscode_pb.js @@ -1,6 +1,8 @@ /** * @fileoverview * @enhanceable + * @suppress {messageConventions} JS Compiler reports an error if a variable or + * field starts with 'MSG_' and isn't a translatable message. * @public */ // GENERATED CODE -- DO NOT EDIT! @@ -53,11 +55,12 @@ proto.SharedProcessActiveMessage.prototype.toObject = function(opt_includeInstan * http://goto/soy-param-migration * @param {!proto.SharedProcessActiveMessage} msg The msg instance to transform. * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages */ proto.SharedProcessActiveMessage.toObject = function(includeInstance, msg) { var f, obj = { - socketPath: msg.getSocketPath(), - logPath: msg.getLogPath() + socketPath: jspb.Message.getFieldWithDefault(msg, 1, ""), + logPath: jspb.Message.getFieldWithDefault(msg, 2, "") }; if (includeInstance) { @@ -111,43 +114,34 @@ proto.SharedProcessActiveMessage.deserializeBinaryFromReader = function(msg, rea }; -/** - * Class method variant: serializes the given message to binary data - * (in protobuf wire format), writing to the given BinaryWriter. - * @param {!proto.SharedProcessActiveMessage} message - * @param {!jspb.BinaryWriter} writer - */ -proto.SharedProcessActiveMessage.serializeBinaryToWriter = function(message, writer) { - message.serializeBinaryToWriter(writer); -}; - - /** * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ proto.SharedProcessActiveMessage.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - this.serializeBinaryToWriter(writer); + proto.SharedProcessActiveMessage.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; /** - * Serializes the message to binary data (in protobuf wire format), - * writing to the given BinaryWriter. + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.SharedProcessActiveMessage} message * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.SharedProcessActiveMessage.prototype.serializeBinaryToWriter = function (writer) { +proto.SharedProcessActiveMessage.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = this.getSocketPath(); + f = message.getSocketPath(); if (f.length > 0) { writer.writeString( 1, f ); } - f = this.getLogPath(); + f = message.getLogPath(); if (f.length > 0) { writer.writeString( 2, @@ -157,27 +151,18 @@ proto.SharedProcessActiveMessage.prototype.serializeBinaryToWriter = function (w }; -/** - * Creates a deep clone of this proto. No data is shared with the original. - * @return {!proto.SharedProcessActiveMessage} The clone. - */ -proto.SharedProcessActiveMessage.prototype.cloneMessage = function() { - return /** @type {!proto.SharedProcessActiveMessage} */ (jspb.Message.cloneMessage(this)); -}; - - /** * optional string socket_path = 1; * @return {string} */ proto.SharedProcessActiveMessage.prototype.getSocketPath = function() { - return /** @type {string} */ (jspb.Message.getFieldProto3(this, 1, "")); + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); }; -/** @param {string} value */ +/** @param {string} value */ proto.SharedProcessActiveMessage.prototype.setSocketPath = function(value) { - jspb.Message.setField(this, 1, value); + jspb.Message.setProto3StringField(this, 1, value); }; @@ -186,13 +171,13 @@ proto.SharedProcessActiveMessage.prototype.setSocketPath = function(value) { * @return {string} */ proto.SharedProcessActiveMessage.prototype.getLogPath = function() { - return /** @type {string} */ (jspb.Message.getFieldProto3(this, 2, "")); + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); }; -/** @param {string} value */ +/** @param {string} value */ proto.SharedProcessActiveMessage.prototype.setLogPath = function(value) { - jspb.Message.setField(this, 2, value); + jspb.Message.setProto3StringField(this, 2, value); }; diff --git a/packages/protocol/test/command.test.ts b/packages/protocol/test/command.test.ts deleted file mode 100644 index a3fffdbcf..000000000 --- a/packages/protocol/test/command.test.ts +++ /dev/null @@ -1,268 +0,0 @@ -import * as cp from "child_process"; -import * as net from "net"; -import * as os from "os"; -import * as path from "path"; -import { TextEncoder, TextDecoder } from "text-encoding"; -import { createClient } from "./helpers"; -import { ChildProcess } from "../src/browser/command"; - -(global as any).TextDecoder = TextDecoder; // tslint:disable-line no-any -(global as any).TextEncoder = TextEncoder; // tslint:disable-line no-any - -describe("spawn", () => { - const client = createClient({ - dataDirectory: "", - workingDirectory: "", - builtInExtensionsDirectory: "", - forkProvider: (msg): cp.ChildProcess => { - return cp.spawn(msg.getCommand(), msg.getArgsList(), { - stdio: [null, null, null, "ipc"], - }); - }, - }); - - /** - * Returns a function that when called returns a promise that resolves with - * the next chunk of data from the process. - */ - const promisifyData = (proc: ChildProcess): (() => Promise) => { - // Use a persistent callback instead of creating it in the promise since - // otherwise we could lose data that comes in while no promise is listening. - let onData: (() => void) | undefined; - let buffer: string | undefined; - proc.stdout.on("data", (data) => { - // Remove everything that isn't a letter, number, or $ to avoid issues - // with ANSI escape codes printing inside the test output. - buffer = (buffer || "") + data.toString().replace(/[^a-zA-Z0-9$]/g, ""); - if (onData) { - onData(); - } - }); - - return (): Promise => new Promise((resolve): void => { - onData = (): void => { - if (typeof buffer !== "undefined") { - const data = buffer; - buffer = undefined; - onData = undefined; - resolve(data); - } - }; - onData(); - }); - }; - - it("should execute command and return output", (done) => { - const proc = client.spawn("echo", ["test"]); - proc.stdout.on("data", (data) => { - expect(data).toEqual("test\n"); - }); - proc.on("exit", (): void => { - done(); - }); - }); - - it("should create shell", async () => { - // Setting the config file to something that shouldn't exist so the test - // isn't affected by custom configuration. - const proc = client.spawn("/bin/bash", ["--rcfile", "/tmp/test/nope/should/not/exist"], { - tty: { - columns: 100, - rows: 10, - }, - }); - - const getData = promisifyData(proc); - - // First it outputs @hostname:cwd - expect((await getData()).length).toBeGreaterThan(1); - - // Then it seems to overwrite that with a shorter prompt in the format of - // [hostname@user]$ - expect((await getData())).toContain("$"); - - proc.kill(); - - await new Promise((resolve): void => { - proc.on("exit", resolve); - }); - }); - - it("should cat", (done) => { - const proc = client.spawn("cat", []); - expect(proc.pid).toBeUndefined(); - proc.stdout.on("data", (data) => { - expect(data).toEqual("banana"); - expect(proc.pid).toBeDefined(); - proc.kill(); - }); - proc.on("exit", () => done()); - proc.send("banana"); - proc.stdin.end(); - }); - - it("should print env variable", (done) => { - const proc = client.spawn("env", [], { - env: { hi: "donkey" }, - }); - proc.stdout.on("data", (data) => { - expect(data).toEqual("hi=donkey\n"); - done(); - }); - }); - - it("should resize", async () => { - // Requires the `tput lines` cmd to be available. - // Setting the config file to something that shouldn't exist so the test - // isn't affected by custom configuration. - const proc = client.spawn("/bin/bash", ["--rcfile", "/tmp/test/nope/should/not/exist"], { - tty: { - columns: 10, - rows: 10, - }, - }); - - const getData = promisifyData(proc); - - // We've already tested these first two bits of output; see shell test. - await getData(); - await getData(); - - proc.send("tput lines\n"); - expect(await getData()).toContain("tput"); - - expect((await getData()).trim()).toContain("10"); - proc.resize!({ - columns: 10, - rows: 50, - }); - - // The prompt again. - await getData(); - await getData(); - - proc.send("tput lines\n"); - expect(await getData()).toContain("tput"); - - expect((await getData())).toContain("50"); - - proc.kill(); - expect(proc.killed).toBeTruthy(); - await new Promise((resolve): void => { - proc.on("exit", resolve); - }); - }); - - it("should fork and echo messages", (done) => { - const proc = client.fork(path.join(__dirname, "forker.js")); - proc.on("message", (msg) => { - expect(msg.bananas).toBeTruthy(); - proc.kill(); - }); - proc.send({ bananas: true }, undefined, true); - proc.on("exit", () => done()); - }); -}); - -describe("createConnection", () => { - const client = createClient(); - const tmpPath = path.join(os.tmpdir(), Math.random().toString()); - let server: net.Server; - beforeAll(async () => { - await new Promise((r): void => { - server = net.createServer().listen(tmpPath, () => { - r(); - }); - }); - }); - - afterAll(() => { - server.close(); - }); - - it("should connect to socket", async () => { - await new Promise((resolve): void => { - const socket = client.createConnection(tmpPath, () => { - socket.end(); - socket.addListener("close", () => { - resolve(); - }); - }); - }); - - await new Promise((resolve): void => { - const socket = new client.Socket(); - socket.connect(tmpPath, () => { - socket.end(); - socket.addListener("close", () => { - resolve(); - }); - }); - }); - }); - - it("should get data from server", (done) => { - server.once("connection", (socket: net.Socket) => { - socket.write("hi how r u"); - }); - - const socket = client.createConnection(tmpPath); - - socket.addListener("data", (data) => { - expect(data.toString()).toEqual("hi how r u"); - socket.end(); - socket.addListener("close", () => { - done(); - }); - }); - }); - - it("should send data to server", (done) => { - const clientSocket = client.createConnection(tmpPath); - clientSocket.write(Buffer.from("bananas")); - server.once("connection", (socket: net.Socket) => { - socket.addListener("data", (data) => { - expect(data.toString()).toEqual("bananas"); - socket.end(); - clientSocket.addListener("end", () => { - done(); - }); - }); - }); - }); -}); - -describe("createServer", () => { - const client = createClient(); - const tmpPath = path.join(os.tmpdir(), Math.random().toString()); - - it("should connect to server", (done) => { - const s = client.createServer(() => { - s.close(); - }); - s.on("close", () => { - done(); - }); - s.listen(tmpPath); - }); - - it("should connect to server and get socket connection", (done) => { - const s = client.createServer(); - s.listen(tmpPath, () => { - net.createConnection(tmpPath, () => { - checks++; - s.close(); - }); - }); - let checks = 0; - s.on("connection", (con) => { - expect(checks).toEqual(1); - con.end(); - checks++; - }); - s.on("close", () => { - expect(checks).toEqual(2); - done(); - }); - }); -}); diff --git a/packages/protocol/test/evaluate.test.ts b/packages/protocol/test/evaluate.test.ts index e58587869..240b4992d 100644 --- a/packages/protocol/test/evaluate.test.ts +++ b/packages/protocol/test/evaluate.test.ts @@ -48,7 +48,7 @@ describe("Evaluate", () => { it("should resolve with promise", async () => { const value = await client.evaluate(async () => { - await new Promise((r) => setTimeout(r, 100)); + await new Promise((r): number => setTimeout(r, 100)); return "donkey"; }); @@ -64,6 +64,11 @@ describe("Evaluate", () => { ae.emit("close"); }); }); + + return { + onDidDispose: (): void => undefined, + dispose: (): void => undefined, + }; }); runner.emit("1"); runner.on("2", () => runner.emit("3")); diff --git a/packages/server/src/cli.ts b/packages/server/src/cli.ts index 9be223ad4..5df1da7c5 100644 --- a/packages/server/src/cli.ts +++ b/packages/server/src/cli.ts @@ -27,6 +27,7 @@ export class Entry extends Command { // Dev flags "bootstrap-fork": flags.string({ hidden: true }), env: flags.string({ hidden: true }), + args: flags.string({ hidden: true }), }; public static args = [{ name: "workdir", @@ -57,10 +58,6 @@ export class Entry extends Command { const { args, flags } = this.parse(Entry); - if (flags.env) { - Object.assign(process.env, JSON.parse(flags.env)); - } - const builtInExtensionsDir = path.join(buildDir || path.join(__dirname, ".."), "build/extensions"); if (flags["bootstrap-fork"]) { const modulePath = flags["bootstrap-fork"]; @@ -69,6 +66,13 @@ export class Entry extends Command { process.exit(1); } + Object.assign(process.env, flags.env ? JSON.parse(flags.env) : {}); + ((flags.args ? JSON.parse(flags.args) : []) as string[]).forEach((arg, i) => { + // [0] contains the binary running the script (`node` for example) and + // [1] contains the script name, so the arguments come after that. + process.argv[i + 2] = arg; + }); + return requireModule(modulePath, builtInExtensionsDir); } @@ -110,7 +114,7 @@ export class Entry extends Command { const app = createApp((app) => { app.use((req, res, next) => { res.on("finish", () => { - logger.debug(`\u001B[1m${req.method} ${res.statusCode} \u001B[0m${req.url}`, field("host", req.hostname), field("ip", req.ip)); + logger.trace(`\u001B[1m${req.method} ${res.statusCode} \u001B[0m${req.url}`, field("host", req.hostname), field("ip", req.ip)); }); next(); diff --git a/packages/server/src/server.ts b/packages/server/src/server.ts index 2473bb42e..dfca651b0 100644 --- a/packages/server/src/server.ts +++ b/packages/server/src/server.ts @@ -1,8 +1,6 @@ import { logger } from "@coder/logger"; import { ReadWriteConnection } from "@coder/protocol"; import { Server, ServerOptions } from "@coder/protocol/src/node/server"; -import { NewSessionMessage } from "@coder/protocol/src/proto"; -import { ChildProcess } from "child_process"; import * as express from "express"; //@ts-ignore import * as expressStaticGzip from "express-static-gzip"; @@ -12,7 +10,6 @@ import * as mime from "mime-types"; import * as path from "path"; import * as util from "util"; import * as ws from "ws"; -import { forkModule } from "./vscode/bootstrapFork"; import { isCli, buildDir } from "./constants"; export const createApp = (registerMiddleware?: (app: express.Application) => void, options?: ServerOptions): { @@ -51,23 +48,7 @@ export const createApp = (registerMiddleware?: (app: express.Application) => voi onClose: (cb): void => ws.addEventListener("close", () => cb()), }; - const server = new Server(connection, options ? { - ...options, - forkProvider: (message: NewSessionMessage): ChildProcess => { - let proc: ChildProcess; - if (message.getIsBootstrapFork()) { - const env: NodeJS.ProcessEnv = {}; - message.getEnvMap().forEach((value, key) => { - env[key] = value; - }); - proc = forkModule(message.getCommand(), env); - } else { - throw new Error("No support for non bootstrap-forking yet"); - } - - return proc; - }, - } : undefined); + const server = new Server(connection, options); }); const baseDir = buildDir || path.join(__dirname, ".."); diff --git a/packages/server/src/vscode/bootstrapFork.ts b/packages/server/src/vscode/bootstrapFork.ts index a92abb95b..c41a5443f 100644 --- a/packages/server/src/vscode/bootstrapFork.ts +++ b/packages/server/src/vscode/bootstrapFork.ts @@ -16,10 +16,11 @@ export const requireModule = (modulePath: string, builtInExtensionsDir: string): * Used for loading extensions. Using __non_webpack_require__ didn't work * as it was not resolving to the FS. */ - (global as any).nativeNodeRequire = (id: string) => { + (global as any).nativeNodeRequire = (id: string): any => {// tslint:disable-line no-any const customMod = new mod.Module(id); customMod.filename = id; - customMod.paths = (mod)._nodeModulePaths(path.dirname(id)); + // tslint:disable-next-line no-any + customMod.paths = (mod as any)._nodeModulePaths(path.dirname(id)); if (id.startsWith(builtInExtensionsDir)) { customMod.loaded = true; @@ -28,6 +29,7 @@ export const requireModule = (modulePath: string, builtInExtensionsDir: string): filename: id + ".js", }); req(customMod.exports, customMod.require.bind(customMod), customMod, __filename, path.dirname(id)); + return customMod.exports; } @@ -54,20 +56,24 @@ export const requireModule = (modulePath: string, builtInExtensionsDir: string): * cp.stderr.on("data", (data) => console.log(data.toString("utf8"))); * @param modulePath Path of the VS Code module to load. */ -export const forkModule = (modulePath: string, env?: NodeJS.ProcessEnv): cp.ChildProcess => { - let proc: cp.ChildProcess | undefined; - - const args = ["--bootstrap-fork", modulePath]; - if (env) { - args.push("--env", JSON.stringify(env)); +export const forkModule = (modulePath: string, args: string[], options: cp.ForkOptions): cp.ChildProcess => { + let proc: cp.ChildProcess; + const forkArgs = ["--bootstrap-fork", modulePath]; + if (args) { + forkArgs.push("--args", JSON.stringify(args)); } - const options: cp.SpawnOptions = { + if (options.env) { + // This prevents vscode from trying to load original-fs from electron. + delete options.env.ELECTRON_RUN_AS_NODE; + forkArgs.push("--env", JSON.stringify(options.env)); + } + const forkOptions: cp.ForkOptions = { stdio: [null, null, null, "ipc"], }; if (isCli) { - proc = cp.execFile(process.execPath, args, options); + proc = cp.execFile(process.execPath, forkArgs, forkOptions); } else { - proc = cp.spawn(process.execPath, ["--require", "ts-node/register", "--require", "tsconfig-paths/register", process.argv[1], ...args], options); + proc = cp.spawn(process.execPath, ["--require", "ts-node/register", "--require", "tsconfig-paths/register", process.argv[1], ...forkArgs], forkOptions); } return proc; diff --git a/packages/server/src/vscode/sharedProcess.ts b/packages/server/src/vscode/sharedProcess.ts index 4f6a4c381..675cdc489 100644 --- a/packages/server/src/vscode/sharedProcess.ts +++ b/packages/server/src/vscode/sharedProcess.ts @@ -65,9 +65,11 @@ export class SharedProcess { state: SharedProcessState.Starting, }); let resolved: boolean = false; - this.activeProcess = forkModule("vs/code/electron-browser/sharedProcess/sharedProcessMain", { - VSCODE_ALLOW_IO: "true", - VSCODE_LOGS: process.env.VSCODE_LOGS, + this.activeProcess = forkModule("vs/code/electron-browser/sharedProcess/sharedProcessMain", [], { + env: { + VSCODE_ALLOW_IO: "true", + VSCODE_LOGS: process.env.VSCODE_LOGS, + }, }); this.activeProcess.on("exit", (err) => { if (this._state !== SharedProcessState.Stopped) { diff --git a/packages/vscode/src/client.ts b/packages/vscode/src/client.ts index 6fb618186..fd51d2fd4 100644 --- a/packages/vscode/src/client.ts +++ b/packages/vscode/src/client.ts @@ -1,4 +1,3 @@ -import "./fill/require"; import * as paths from "./fill/paths"; import "./fill/platform"; import "./fill/storageDatabase"; diff --git a/packages/vscode/src/fill/node-pty.ts b/packages/vscode/src/fill/node-pty.ts index e07132054..8f39287c8 100644 --- a/packages/vscode/src/fill/node-pty.ts +++ b/packages/vscode/src/fill/node-pty.ts @@ -1,40 +1,79 @@ import { client } from "@coder/ide/src/fill/client"; import { EventEmitter } from "events"; import * as nodePty from "node-pty"; -import { ChildProcess } from "@coder/protocol/src/browser/command"; +import { ActiveEval } from "@coder/protocol"; -type nodePtyType = typeof nodePty; +// Use this to prevent Webpack from hijacking require. +declare var __non_webpack_require__: typeof require; /** * Implementation of nodePty for the browser. */ class Pty implements nodePty.IPty { private readonly emitter = new EventEmitter(); - private readonly cp: ChildProcess; + private readonly ae: ActiveEval; + private _pid = -1; + private _process = ""; public constructor(file: string, args: string[] | string, options: nodePty.IPtyForkOptions) { - this.cp = client.spawn(file, Array.isArray(args) ? args : [args], { + this.ae = client.run((ae, file, args, options) => { + const nodePty = __non_webpack_require__("node-pty") as typeof import("node-pty"); + const { preserveEnv } = __non_webpack_require__("@coder/ide/src/fill/evaluation") as typeof import("@coder/ide/src/fill/evaluation"); + + preserveEnv(options); + + const ptyProc = nodePty.spawn(file, args, options); + + let process = ptyProc.process; + ae.emit("process", process); + ae.emit("pid", ptyProc.pid); + + const timer = setInterval(() => { + if (ptyProc.process !== process) { + process = ptyProc.process; + ae.emit("process", process); + } + }, 200); + + ptyProc.on("exit", (code, signal) => { + clearTimeout(timer); + ae.emit("exit", code, signal); + }); + + ptyProc.on("data", (data) => ae.emit("data", data)); + + ae.on("resize", (cols, rows) => ptyProc.resize(cols, rows)); + ae.on("write", (data) => ptyProc.write(data)); + ae.on("kill", (signal) => ptyProc.kill(signal)); + + return { + onDidDispose: (cb): void => ptyProc.on("exit", cb), + dispose: (): void => { + ptyProc.kill(); + setTimeout(() => ptyProc.kill("SIGKILL"), 5000); // Double tap. + }, + }; + }, file, Array.isArray(args) ? args : [args], { ...options, tty: { columns: options.cols || 100, rows: options.rows || 100, }, - }); - this.on("write", (d) => this.cp.send(d)); - this.on("kill", (exitCode) => this.cp.kill(exitCode)); - this.on("resize", (cols, rows) => this.cp.resize!({ columns: cols, rows })); + }, file, args, options); - this.cp.stdout.on("data", (data) => this.emitter.emit("data", data)); - this.cp.stderr.on("data", (data) => this.emitter.emit("data", data)); - this.cp.on("exit", (code) => this.emitter.emit("exit", code)); + this.ae.on("pid", (pid) => this._pid = pid); + this.ae.on("process", (process) => this._process = process); + + this.ae.on("exit", (code, signal) => this.emitter.emit("exit", code, signal)); + this.ae.on("data", (data) => this.emitter.emit("data", data)); } public get pid(): number { - return this.cp.pid!; + return this._pid; } public get process(): string { - return this.cp.title!; + return this._process; } // tslint:disable-next-line no-any @@ -43,19 +82,19 @@ class Pty implements nodePty.IPty { } public resize(columns: number, rows: number): void { - this.emitter.emit("resize", columns, rows); + this.ae.emit("resize", columns, rows); } public write(data: string): void { - this.emitter.emit("write", data); + this.ae.emit("write", data); } public kill(signal?: string): void { - this.emitter.emit("kill", signal); + this.ae.emit("kill", signal); } } -const ptyType: nodePtyType = { +const ptyType: typeof nodePty = { spawn: (file: string, args: string[] | string, options: nodePty.IPtyForkOptions): nodePty.IPty => { return new Pty(file, args, options); }, diff --git a/packages/vscode/src/fill/require.ts b/packages/vscode/src/fill/require.ts deleted file mode 100644 index 75053823b..000000000 --- a/packages/vscode/src/fill/require.ts +++ /dev/null @@ -1 +0,0 @@ -require("path").posix = require("path"); diff --git a/packages/vscode/src/fill/spdlog.ts b/packages/vscode/src/fill/spdlog.ts index ff0403689..caed24db2 100644 --- a/packages/vscode/src/fill/spdlog.ts +++ b/packages/vscode/src/fill/spdlog.ts @@ -1,184 +1,67 @@ -import { exec } from "child_process"; -import { promisify } from "util"; -import { appendFile, stat, readdir } from "fs"; +/// import { RotatingLogger as NodeRotatingLogger } from "spdlog"; -import { logger, field } from "@coder/logger"; -import { escapePath } from "@coder/protocol"; +import { logger } from "@coder/logger"; +import { client } from "@coder/ide/src/fill/client"; -// TODO: It would be better to spawn an actual spdlog instance on the server and -// use that for the logging. Or maybe create an instance when the server starts, -// and just always use that one (make it part of the protocol). +declare var __non_webpack_require__: typeof require; + +const ae = client.run((ae) => { + const spdlog = __non_webpack_require__("spdlog") as typeof import("spdlog"); + const loggers = new Map(); + + ae.on("new", (id, name, filePath, fileSize, fileCount) => { + const logger = new spdlog.RotatingLogger(name, filePath, fileSize, fileCount); + loggers.set(id, logger); + }); + + ae.on("clearFormatters", (id) => loggers.get(id)!.clearFormatters()); + ae.on("critical", (id, message) => loggers.get(id)!.critical(message)); + ae.on("debug", (id, message) => loggers.get(id)!.debug(message)); + ae.on("drop", (id) => loggers.get(id)!.drop()); + ae.on("errorLog", (id, message) => loggers.get(id)!.error(message)); + ae.on("flush", (id) => loggers.get(id)!.flush()); + ae.on("info", (id, message) => loggers.get(id)!.info(message)); + ae.on("setAsyncMode", (bufferSize, flushInterval) => spdlog.setAsyncMode(bufferSize, flushInterval)); + ae.on("setLevel", (id, level) => loggers.get(id)!.setLevel(level)); + ae.on("trace", (id, message) => loggers.get(id)!.trace(message)); + ae.on("warn", (id, message) => loggers.get(id)!.warn(message)); + + const disposeCallbacks = void>>[]; + + return { + onDidDispose: (cb): number => disposeCallbacks.push(cb), + dispose: (): void => { + loggers.forEach((logger) => logger.flush()); + loggers.clear(); + disposeCallbacks.forEach((cb) => cb()); + }, + }; +}); + +const spdLogger = logger.named("spdlog"); +ae.on("close", () => spdLogger.error("session closed prematurely")); +ae.on("error", (error) => spdLogger.error(error.message)); + +let id = 0; export class RotatingLogger implements NodeRotatingLogger { - private format = true; - private buffer = ""; - private flushPromise: Promise | undefined; - private name: string; - private logDirectory: string; - private escapedLogDirectory: string; - private fullFilePath: string; - private fileName: string; - private fileExt: string | undefined; - private escapedFilePath: string; - private filesize: number; - private filecount: number; + private readonly id = id++; - public constructor(name: string, filePath: string, filesize: number, filecount: number) { - this.name = name; - this.filesize = filesize; - this.filecount = filecount; - - this.fullFilePath = filePath; - const slashIndex = filePath.lastIndexOf("/"); - const dotIndex = filePath.lastIndexOf("."); - this.logDirectory = slashIndex !== -1 ? filePath.substring(0, slashIndex) : "/"; - this.fileName = filePath.substring(slashIndex + 1, dotIndex !== -1 ? dotIndex : undefined); - this.fileExt = dotIndex !== -1 ? filePath.substring(dotIndex + 1) : undefined; - - this.escapedLogDirectory = escapePath(this.logDirectory); - this.escapedFilePath = escapePath(filePath); - - this.flushPromise = new Promise((resolve): void => { - exec(`mkdir -p ${this.escapedLogDirectory}; touch ${this.escapedFilePath}`, async (error) => { - if (!error) { - try { - await this.doFlush(); - } catch (e) { - error = e; - } - } - if (error) { - logger.error(error.message, field("error", error)); - } - this.flushPromise = undefined; - resolve(); - }); - }); + public constructor(name: string, filePath: string, fileSize: number, fileCount: number) { + ae.emit("new", this.id, name, filePath, fileSize, fileCount); } - public trace(message: string): void { - this.write("trace", message); - } - - public debug(message: string): void { - this.write("debug", message); - } - - public info(message: string): void { - this.write("info", message); - } - - public warn(message: string): void { - this.write("warn", message); - } - - public error(message: string): void { - this.write("error", message); - } - - public critical(message: string): void { - this.write("critical", message); - } - - public setLevel(): void { - // Should output everything. - } - - public clearFormatters(): void { - this.format = false; - } - - /** - * Flushes the buffer. Only one process runs at a time to prevent race - * conditions. - */ - public flush(): Promise { - if (!this.flushPromise) { - this.flushPromise = this.doFlush().then(() => { - this.flushPromise = undefined; - }).catch((error) => { - this.flushPromise = undefined; - logger.error(error.message, field("error", error)); - }); - } - - return this.flushPromise; - } - - public drop(): void { - this.buffer = ""; - } - - private pad(num: number, length: number = 2, prefix: string = "0"): string { - const str = num.toString(); - - return (length > str.length ? prefix.repeat(length - str.length) : "") + str; - } - - private write(severity: string, message: string): void { - if (this.format) { - const date = new Date(); - const dateStr = `${date.getFullYear()}-${this.pad(date.getMonth() + 1)}-${this.pad(date.getDate())}` - + ` ${this.pad(date.getHours())}:${this.pad(date.getMinutes())}:${this.pad(date.getSeconds())}.${this.pad(date.getMilliseconds(), 3)}`; - this.buffer += `[${dateStr}] [${this.name}] [${severity}] `; - } - this.buffer += message; - if (this.format) { - this.buffer += "\n"; - } - this.flush(); - } - - private async rotate(): Promise { - const stats = await promisify(stat)(this.fullFilePath); - if (stats.size < this.filesize) { - return; - } - - const reExt = typeof this.fileExt !== "undefined" ? `\\.${this.fileExt}` : ""; - const re = new RegExp(`^${this.fileName}(?:\\.(\\d+))?${reExt}$`); - const orderedFiles: string[] = []; - (await promisify(readdir)(this.logDirectory)).forEach((file) => { - const match = re.exec(file); - if (match) { - orderedFiles[typeof match[1] !== "undefined" ? parseInt(match[1], 10) : 0] = file; - } - }); - - // Rename in reverse so we don't overwrite before renaming something. - let count = 0; - const command = orderedFiles.map((file) => { - const fileExt = typeof this.fileExt !== "undefined" ? `.${this.fileExt}` : ""; - const newFile = `${this.logDirectory}/${this.fileName}.${++count}${fileExt}`; - - return count >= this.filecount - ? `rm ${escapePath(this.logDirectory + "/" + file)}` - : `mv ${escapePath(this.logDirectory + "/" + file)} ${escapePath(newFile)}`; - }).reverse().concat([ - `touch ${escapePath(this.fullFilePath)}`, - ]).join(";"); - - await promisify(exec)(command); - } - - /** - * Flushes the entire buffer, including anything added in the meantime, and - * rotates the log if necessary. - */ - private async doFlush(): Promise { - const writeBuffer = async (): Promise => { - const toWrite = this.buffer; - this.buffer = ""; - - await promisify(appendFile)(this.fullFilePath, toWrite); - }; - - while (this.buffer.length > 0) { - await writeBuffer(); - await this.rotate(); - } - } + public trace(message: string): void { ae.emit("trace", this.id, message); } + public debug(message: string): void { ae.emit("debug", this.id, message); } + public info(message: string): void { ae.emit("info", this.id, message); } + public warn(message: string): void { ae.emit("warn", this.id, message); } + public error(message: string): void { ae.emit("errorLog", this.id, message); } + public critical(message: string): void { ae.emit("critical", this.id, message); } + public setLevel(level: number): void { ae.emit("setLevel", this.id, level); } + public clearFormatters(): void { ae.emit("clearFormatters", this.id); } + public flush(): void { ae.emit("flush", this.id); } + public drop(): void { ae.emit("drop", this.id); } } -export const setAsyncMode = (): void => { - // Nothing to do. +export const setAsyncMode = (bufferSize: number, flushInterval: number): void => { + ae.emit("setAsyncMode", bufferSize, flushInterval); }; diff --git a/packages/web/webpack.common.config.js b/packages/web/webpack.common.config.js index 40ce81aee..a71bbc025 100644 --- a/packages/web/webpack.common.config.js +++ b/packages/web/webpack.common.config.js @@ -38,6 +38,11 @@ module.exports = merge({ "readline": path.join(fills, "empty.ts"), "oniguruma": path.join(fills, "empty.ts"), + // Webpack includes path-browserify but not the latest version, so + // path.posix and path.parse are undefined (among other things possibly). + // Also if we don't provide the full path, the code in vscode will import + // from vscode's node_modules which is the wrong version. + "path": path.join(root, "node_modules", "path-browserify"), "crypto": "crypto-browserify", "http": "http-browserify", diff --git a/scripts/vscode.patch b/scripts/vscode.patch index c93bdd3fb..4db4cae11 100644 --- a/scripts/vscode.patch +++ b/scripts/vscode.patch @@ -122,12 +122,37 @@ index 8d182d18d9..69d51e1aea 100644 @@ -132 +132 @@ function connectToRenderer(protocol: IMessagePassingProtocol): Promise((resolve, reject) => { ++ return new Promise(async (resolve, reject) => { +@@ -320 +320 @@ export class ExecutableDebugAdapter extends StreamDebugAdapter { +- if (!fs.existsSync(this.adapterExecutable.command)) { ++ if (!(await require("util").promisify(fs.exists)(this.adapterExecutable.command))) { diff --git a/src/vs/workbench/parts/files/electron-browser/views/explorerViewer.ts b/src/vs/workbench/parts/files/electron-browser/views/explorerViewer.ts index e600fb2f78..1e0dc9a220 100644 --- a/src/vs/workbench/parts/files/electron-browser/views/explorerViewer.ts +++ b/src/vs/workbench/parts/files/electron-browser/views/explorerViewer.ts @@ -934,0 +935 @@ export class FileDragAndDrop extends SimpleFileResourceDragAndDrop { + return (require('vs/../../../../packages/vscode') as typeof import ('vs/../../../../packages/vscode')).client.handleExternalDrop(target, originalEvent); +diff --git a/src/vs/workbench/parts/logs/electron-browser/logs.contribution.ts b/src/vs/workbench/parts/logs/electron-browser/logs.contribution.ts +index 4015c9cd5d..bebdb25f6c 100644 +--- a/src/vs/workbench/parts/logs/electron-browser/logs.contribution.ts ++++ b/src/vs/workbench/parts/logs/electron-browser/logs.contribution.ts +@@ -31 +31,2 @@ class LogOutputChannels extends Disposable implements IWorkbenchContribution { +- outputChannelRegistry.registerChannel({ id: Constants.mainLogChannelId, label: nls.localize('mainLog', "Main"), file: URI.file(join(environmentService.logsPath, `main.log`)), log: true }); ++ // This channel only seems to be used when loading the app and we skip all of that, so it is never actually created or written to. ++ // outputChannelRegistry.registerChannel({ id: Constants.mainLogChannelId, label: nls.localize('mainLog', "Main"), file: URI.file(join(environmentService.logsPath, `main.log`)), log: true }); +diff --git a/src/vs/workbench/parts/output/common/outputLinkProvider.ts b/src/vs/workbench/parts/output/common/outputLinkProvider.ts +index 63437034c9..acd82c8375 100644 +--- a/src/vs/workbench/parts/output/common/outputLinkProvider.ts ++++ b/src/vs/workbench/parts/output/common/outputLinkProvider.ts +@@ -77,0 +78,2 @@ export class OutputLinkProvider { ++ // TODO@coder: get this working. ++ return Promise.resolve([]); diff --git a/src/vs/workbench/parts/welcome/walkThrough/node/walkThroughContentProvider.ts b/src/vs/workbench/parts/welcome/walkThrough/node/walkThroughContentProvider.ts index 7b4e8721ac..96d612f940 100644 --- a/src/vs/workbench/parts/welcome/walkThrough/node/walkThroughContentProvider.ts diff --git a/scripts/webpack.general.config.js b/scripts/webpack.general.config.js index be907d12e..dcda9a7e2 100644 --- a/scripts/webpack.general.config.js +++ b/scripts/webpack.general.config.js @@ -44,7 +44,7 @@ module.exports = (options = {}) => ({ // These are meant to run in separate pages, like the issue reporter or // process explorer. Ignoring for now since otherwise their CSS is // included in the main CSS. - test: /electron-browser.+\.html$|code\/electron-browser\/.+\.css$/, + test: /test|electron-browser.+\.html$|code\/electron-browser\/.+\.css$/, use: [{ loader: "ignore-loader", }], diff --git a/yarn.lock b/yarn.lock index de2c8d306..a3459e75d 100644 --- a/yarn.lock +++ b/yarn.lock @@ -506,6 +506,13 @@ binary-extensions@^1.0.0: resolved "https://registry.yarnpkg.com/binary-extensions/-/binary-extensions-1.12.0.tgz#c2d780f53d45bba8317a8902d4ceeaf3a6385b14" integrity sha512-DYWGk01lDcxeS/K9IHPGWfT8PsJmbXRtRd2Sx72Tnb8pcYZQFF1oSDb8hJtS1vhp212q1Rzi5dUf9+nq0o9UIg== +bindings@^1.3.0: + version "1.4.0" + resolved "https://registry.yarnpkg.com/bindings/-/bindings-1.4.0.tgz#909efa49f2ebe07ecd3cb136778f665052040127" + integrity sha512-7znEVX22Djn+nYjxCWKDne0RRloa9XfYa84yk3s+HkE3LpDYZmhArYr9O9huBoHY3/oXispx5LorIX7Sl2CgSQ== + dependencies: + file-uri-to-path "1.0.0" + block-stream@*: version "0.0.9" resolved "https://registry.yarnpkg.com/block-stream/-/block-stream-0.0.9.tgz#13ebfe778a03205cfe03751481ebb4b3300c126a" @@ -1775,6 +1782,11 @@ file-loader@^3.0.1: loader-utils "^1.0.2" schema-utils "^1.0.0" +file-uri-to-path@1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/file-uri-to-path/-/file-uri-to-path-1.0.0.tgz#553a7b8446ff6f684359c445f1e37a05dacc33dd" + integrity sha512-0Zt+s3L7Vf1biwWZ29aARiVYLx7iMGnEUl9x33fbB/j3jR81u/O2LbqK+Bm1CDSNDKVtJ/YjwY7TUd5SkeLQLw== + filesize@^3.6.1: version "3.6.1" resolved "https://registry.yarnpkg.com/filesize/-/filesize-3.6.1.tgz#090bb3ee01b6f801a8a8be99d31710b3422bb317" @@ -3317,7 +3329,7 @@ multicast-dns@^6.0.1: dns-packet "^1.3.1" thunky "^1.0.2" -nan@^2.10.0, nan@^2.9.2: +nan@^2.10.0, nan@^2.8.0, nan@^2.9.2: version "2.12.1" resolved "https://registry.yarnpkg.com/nan/-/nan-2.12.1.tgz#7b1aa193e9aa86057e3c7bbd0ac448e770925552" integrity sha512-JY7V6lRkStKcKTvHO5NVSQRv+RV+FIL5pvDoLiAtSL9pKlC5x9PKQcZDsq7m4FO4d57mkhC6Z+QhAh3Jdk5JFw== @@ -3803,6 +3815,11 @@ path-browserify@0.0.0: resolved "https://registry.yarnpkg.com/path-browserify/-/path-browserify-0.0.0.tgz#a0b870729aae214005b7d5032ec2cbbb0fb4451a" integrity sha1-oLhwcpquIUAFt9UDLsLLuw+0RRo= +path-browserify@^1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/path-browserify/-/path-browserify-1.0.0.tgz#40702a97af46ae00b0ea6fa8998c0b03c0af160d" + integrity sha512-Hkavx/nY4/plImrZPHRk2CL9vpOymZLgEbMNX1U0bjcBL7QN9wODxyx0yaMZURSQaUtSEvDrfAvxa9oPb0at9g== + path-dirname@^1.0.0: version "1.0.2" resolved "https://registry.yarnpkg.com/path-dirname/-/path-dirname-1.0.2.tgz#cc33d24d525e099a5388c0336c6e32b9160609e0" @@ -4719,6 +4736,15 @@ source-map@^0.6.0, source-map@^0.6.1, source-map@~0.6.0, source-map@~0.6.1: resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.6.1.tgz#74722af32e9614e9c287a8d0bbde48b5e2f1a263" integrity sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g== +spdlog@^0.7.2: + version "0.7.2" + resolved "https://registry.yarnpkg.com/spdlog/-/spdlog-0.7.2.tgz#9298753d7694b9ee9bbfd7e01ea1e4c6ace1e64d" + integrity sha512-rHfWCaWMD4NindDnql6rc6kn7Bs8JR92jhiUpCl3D6v+jYcQ6GozMLig0RliOOR8st5mU+IHLZnr15fBys5x/Q== + dependencies: + bindings "^1.3.0" + mkdirp "^0.5.1" + nan "^2.8.0" + spdx-correct@^3.0.0: version "3.1.0" resolved "https://registry.yarnpkg.com/spdx-correct/-/spdx-correct-3.1.0.tgz#fb83e504445268f154b074e218c87c003cd31df4"