a
/
code-server
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Convert fully to protobuf (was partially JSON) (#402) 

* Convert fully to protobuf (was partially JSON)

* Handle all floating promises

* Remove stringified proto from trace logging

It wasn't proving to be very useful.
This commit is contained in:
Asher 2019-04-02 17:44:28 -05:00 committed by Kyle Carberry
parent f484781693
commit 3a672d725a
31 changed files with 5788 additions and 3277 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

85
packages/protocol/src/browser/client.ts
View File

@ -5,8 +5,8 @@ import { Emitter } from "@coder/events";
import { logger, field } from "@coder/logger"; import { logger, field } from "@coder/logger";
import { ReadWriteConnection, InitData, SharedProcessData } from "../common/connection"; import { ReadWriteConnection, InitData, SharedProcessData } from "../common/connection";
import { Module, ServerProxy } from "../common/proxy"; import { Module, ServerProxy } from "../common/proxy";
import { stringify, parse, moduleToProto, protoToModule, protoToOperatingSystem } from "../common/util"; import { argumentToProto, protoToArgument, moduleToProto, protoToModule, protoToOperatingSystem } from "../common/util";
import { Ping, ServerMessage, ClientMessage, MethodMessage, NamedProxyMessage, NumberedProxyMessage, SuccessMessage, FailMessage, EventMessage, CallbackMessage } from "../proto"; import { Argument, Ping, ServerMessage, ClientMessage, Method, Event, Callback } from "../proto";
import { FsModule, ChildProcessModule, NetModule, NodePtyModule, SpdlogModule, TrashModule } from "./modules"; import { FsModule, ChildProcessModule, NetModule, NodePtyModule, SpdlogModule, TrashModule } from "./modules";
// tslint:disable no-any // tslint:disable no-any
@ -24,8 +24,8 @@ export class Client {
private messageId = 0; private messageId = 0;
private callbackId = 0; private callbackId = 0;
private readonly proxies = new Map<number | Module, ProxyData>(); private readonly proxies = new Map<number | Module, ProxyData>();
private readonly successEmitter = new Emitter<SuccessMessage>(); private readonly successEmitter = new Emitter<Method.Success>();
private readonly failEmitter = new Emitter<FailMessage>(); private readonly failEmitter = new Emitter<Method.Fail>();
private readonly eventEmitter = new Emitter<{ event: string; args: any[]; }>(); private readonly eventEmitter = new Emitter<{ event: string; args: any[]; }>();
private _initData: InitData | undefined; private _initData: InitData | undefined;
@ -129,9 +129,9 @@ export class Client {
field("event listeners", this.eventEmitter.counts), field("event listeners", this.eventEmitter.counts),
]); ]);
const message = new FailMessage(); const message = new Method.Fail();
const error = new Error("disconnected"); const error = new Error("disconnected");
message.setResponse(stringify(error)); message.setResponse(argumentToProto(error));
this.failEmitter.emit(message); this.failEmitter.emit(message);
this.eventEmitter.emit({ event: "disconnected", args: [error] }); this.eventEmitter.emit({ event: "disconnected", args: [error] });
@ -182,20 +182,21 @@ export class Client {
case "kill": case "kill":
return Promise.resolve(); return Promise.resolve();
} }
return Promise.reject( return Promise.reject(
new Error(`Unable to call "${method}" on proxy ${proxyId}: disconnected`), new Error(`Unable to call "${method}" on proxy ${proxyId}: disconnected`),
); );
} }
const message = new MethodMessage(); const message = new Method();
const id = this.messageId++; const id = this.messageId++;
let proxyMessage: NamedProxyMessage | NumberedProxyMessage; let proxyMessage: Method.Named | Method.Numbered;
if (typeof proxyId === "string") { if (typeof proxyId === "string") {
proxyMessage = new NamedProxyMessage(); proxyMessage = new Method.Named();
proxyMessage.setModule(moduleToProto(proxyId)); proxyMessage.setModule(moduleToProto(proxyId));
message.setNamedProxy(proxyMessage); message.setNamedProxy(proxyMessage);
} else { } else {
proxyMessage = new NumberedProxyMessage(); proxyMessage = new Method.Numbered();
proxyMessage.setProxyId(proxyId); proxyMessage.setProxyId(proxyId);
message.setNumberedProxy(proxyMessage); message.setNumberedProxy(proxyMessage);
} }
@ -215,16 +216,14 @@ export class Client {
return callbackId; return callbackId;
}; };
const stringifiedArgs = args.map((a) => stringify(a, storeCallback));
logger.trace(() => [ logger.trace(() => [
"sending", "sending",
field("id", id), field("id", id),
field("proxyId", proxyId), field("proxyId", proxyId),
field("method", method), field("method", method),
field("args", stringifiedArgs),
]); ]);
proxyMessage.setArgsList(stringifiedArgs); proxyMessage.setArgsList(args.map((a) => argumentToProto(a, storeCallback)));
const clientMessage = new ClientMessage(); const clientMessage = new ClientMessage();
clientMessage.setMethod(message); clientMessage.setMethod(message);
@ -246,12 +245,12 @@ export class Client {
const d1 = this.successEmitter.event(id, (message) => { const d1 = this.successEmitter.event(id, (message) => {
dispose(); dispose();
resolve(this.parse(message.getResponse(), promise)); resolve(this.protoToArgument(message.getResponse(), promise));
}); });
const d2 = this.failEmitter.event(id, (message) => { const d2 = this.failEmitter.event(id, (message) => {
dispose(); dispose();
reject(parse(message.getResponse())); reject(protoToArgument(message.getResponse()));
}); });
}); });
@ -262,7 +261,8 @@ export class Client {
* Handle all messages from the server. * Handle all messages from the server.
*/ */
private async handleMessage(message: ServerMessage): Promise<void> { private async handleMessage(message: ServerMessage): Promise<void> {
if (message.hasInit()) { switch (message.getMsgCase()) {
case ServerMessage.MsgCase.INIT:
const init = message.getInit()!; const init = message.getInit()!;
this._initData = { this._initData = {
dataDirectory: init.getDataDirectory(), dataDirectory: init.getDataDirectory(),
@ -274,30 +274,40 @@ export class Client {
builtInExtensionsDirectory: init.getBuiltinExtensionsDir(), builtInExtensionsDirectory: init.getBuiltinExtensionsDir(),
}; };
this.initDataEmitter.emit(this._initData); this.initDataEmitter.emit(this._initData);
} else if (message.hasSuccess()) { break;
case ServerMessage.MsgCase.SUCCESS:
this.emitSuccess(message.getSuccess()!); this.emitSuccess(message.getSuccess()!);
} else if (message.hasFail()) { break;
case ServerMessage.MsgCase.FAIL:
this.emitFail(message.getFail()!); this.emitFail(message.getFail()!);
} else if (message.hasEvent()) { break;
case ServerMessage.MsgCase.EVENT:
await this.emitEvent(message.getEvent()!); await this.emitEvent(message.getEvent()!);
} else if (message.hasCallback()) { break;
case ServerMessage.MsgCase.CALLBACK:
await this.runCallback(message.getCallback()!); await this.runCallback(message.getCallback()!);
} else if (message.hasSharedProcessActive()) { break;
case ServerMessage.MsgCase.SHARED_PROCESS_ACTIVE:
const sharedProcessActiveMessage = message.getSharedProcessActive()!; const sharedProcessActiveMessage = message.getSharedProcessActive()!;
this.sharedProcessActiveEmitter.emit({ this.sharedProcessActiveEmitter.emit({
socketPath: sharedProcessActiveMessage.getSocketPath(), socketPath: sharedProcessActiveMessage.getSocketPath(),
logPath: sharedProcessActiveMessage.getLogPath(), logPath: sharedProcessActiveMessage.getLogPath(),
}); });
} else if (message.hasPong()) { break;
case ServerMessage.MsgCase.PONG:
// Nothing to do since pings are on a timer rather than waiting for the // Nothing to do since pings are on a timer rather than waiting for the
// next pong in case a message from either the client or server is dropped // next pong in case a message from either the client or server is dropped
// which would break the ping cycle. // which would break the ping cycle.
} else { break;
default:
throw new Error("unknown message type"); throw new Error("unknown message type");
} }
} }
private emitSuccess(message: SuccessMessage): void { /**
* Convert message to a success event.
*/
private emitSuccess(message: Method.Success): void {
logger.trace(() => [ logger.trace(() => [
"received resolve", "received resolve",
field("id", message.getId()), field("id", message.getId()),
@ -306,7 +316,10 @@ export class Client {
this.successEmitter.emit(message.getId(), message); this.successEmitter.emit(message.getId(), message);
} }
private emitFail(message: FailMessage): void { /**
* Convert message to a fail event.
*/
private emitFail(message: Method.Fail): void {
logger.trace(() => [ logger.trace(() => [
"received reject", "received reject",
field("id", message.getId()), field("id", message.getId()),
@ -322,7 +335,7 @@ export class Client {
* request before it emits. Instead, emit all events from the server so all * request before it emits. Instead, emit all events from the server so all
* events are always caught on the client. * events are always caught on the client.
*/ */
private async emitEvent(message: EventMessage): Promise<void> { private async emitEvent(message: Event): Promise<void> {
const eventMessage = message.getNamedEvent()! || message.getNumberedEvent()!; const eventMessage = message.getNamedEvent()! || message.getNumberedEvent()!;
const proxyId = message.getNamedEvent() const proxyId = message.getNamedEvent()
? protoToModule(message.getNamedEvent()!.getModule()) ? protoToModule(message.getNamedEvent()!.getModule())
@ -333,10 +346,9 @@ export class Client {
"received event", "received event",
field("proxyId", proxyId), field("proxyId", proxyId),
field("event", event), field("event", event),
field("args", eventMessage.getArgsList()),
]); ]);
const args = eventMessage.getArgsList().map((a) => this.parse(a)); const args = eventMessage.getArgsList().map((a) => this.protoToArgument(a));
this.eventEmitter.emit(proxyId, { event, args }); this.eventEmitter.emit(proxyId, { event, args });
} }
@ -348,7 +360,7 @@ export class Client {
* also only be used when passed together with the method. If they are sent * also only be used when passed together with the method. If they are sent
* afterward, they may never be called due to timing issues. * afterward, they may never be called due to timing issues.
*/ */
private async runCallback(message: CallbackMessage): Promise<void> { private async runCallback(message: Callback): Promise<void> {
const callbackMessage = message.getNamedCallback()! || message.getNumberedCallback()!; const callbackMessage = message.getNamedCallback()! || message.getNumberedCallback()!;
const proxyId = message.getNamedCallback() const proxyId = message.getNamedCallback()
? protoToModule(message.getNamedCallback()!.getModule()) ? protoToModule(message.getNamedCallback()!.getModule())
@ -359,16 +371,15 @@ export class Client {
"running callback", "running callback",
field("proxyId", proxyId), field("proxyId", proxyId),
field("callbackId", callbackId), field("callbackId", callbackId),
field("args", callbackMessage.getArgsList()),
]); ]);
const args = callbackMessage.getArgsList().map((a) => this.parse(a)); const args = callbackMessage.getArgsList().map((a) => this.protoToArgument(a));
this.getProxy(proxyId).callbacks.get(callbackId)!(...args); this.getProxy(proxyId).callbacks.get(callbackId)!(...args);
} }
/** /**
* Start the ping loop. Does nothing if already pinging. * Start the ping loop. Does nothing if already pinging.
*/ */
private startPinging = (): void => { private readonly startPinging = (): void => {
if (typeof this.pingTimeout !== "undefined") { if (typeof this.pingTimeout !== "undefined") {
return; return;
} }
@ -505,10 +516,16 @@ export class Client {
await this.getProxy(proxyId).promise; await this.getProxy(proxyId).promise;
} }
private parse(value?: string, promise?: Promise<any>): any { /**
return parse(value, undefined, (id) => this.createProxy(id, promise)); * Same as protoToArgument except provides createProxy.
*/
private protoToArgument(value?: Argument, promise?: Promise<any>): any {
return protoToArgument(value, undefined, (id) => this.createProxy(id, promise));
} }
/**
* Get a proxy. Error if it doesn't exist.
*/
private getProxy(proxyId: number | Module): ProxyData { private getProxy(proxyId: number | Module): ProxyData {
if (!this.proxies.has(proxyId)) { if (!this.proxies.has(proxyId)) {
throw new Error(`proxy ${proxyId} disposed too early`); throw new Error(`proxy ${proxyId} disposed too early`);

17
packages/protocol/src/browser/modules/child_process.ts
View File

@ -6,6 +6,8 @@ import { ClientProxy } from "../../common/proxy";
import { ChildProcessModuleProxy, ChildProcessProxy, ChildProcessProxies } from "../../node/modules/child_process"; import { ChildProcessModuleProxy, ChildProcessProxy, ChildProcessProxies } from "../../node/modules/child_process";
import { Readable, Writable } from "./stream"; import { Readable, Writable } from "./stream";
// tslint:disable completed-docs
export class ChildProcess extends ClientProxy<ChildProcessProxy> implements cp.ChildProcess { export class ChildProcess extends ClientProxy<ChildProcessProxy> implements cp.ChildProcess {
public readonly stdin: stream.Writable; public readonly stdin: stream.Writable;
public readonly stdout: stream.Readable; public readonly stdout: stream.Readable;
@ -23,10 +25,10 @@ export class ChildProcess extends ClientProxy<ChildProcessProxy> implements cp.C
this.stderr = new Readable(proxyPromises.then((p) => p.stderr!)); this.stderr = new Readable(proxyPromises.then((p) => p.stderr!));
this.stdio = [this.stdin, this.stdout, this.stderr]; this.stdio = [this.stdin, this.stdout, this.stderr];
this.proxy.getPid().then((pid) => { this.catch(this.proxy.getPid().then((pid) => {
this._pid = pid; this._pid = pid;
this._connected = true; this._connected = true;
}); }));
this.on("disconnect", () => this._connected = false); this.on("disconnect", () => this._connected = false);
this.on("exit", () => { this.on("exit", () => {
this._connected = false; this._connected = false;
@ -48,19 +50,19 @@ export class ChildProcess extends ClientProxy<ChildProcessProxy> implements cp.C
public kill(): void { public kill(): void {
this._killed = true; this._killed = true;
this.proxy.kill(); this.catch(this.proxy.kill());
} }
public disconnect(): void { public disconnect(): void {
this.proxy.disconnect(); this.catch(this.proxy.disconnect());
} }
public ref(): void { public ref(): void {
this.proxy.ref(); this.catch(this.proxy.ref());
} }
public unref(): void { public unref(): void {
this.proxy.unref(); this.catch(this.proxy.unref());
} }
public send( public send(
@ -88,6 +90,9 @@ export class ChildProcess extends ClientProxy<ChildProcessProxy> implements cp.C
return true; // Always true since we can't get this synchronously. return true; // Always true since we can't get this synchronously.
} }
/**
* Exit and close the process when disconnected.
*/
protected handleDisconnect(): void { protected handleDisconnect(): void {
this.emit("exit", 1); this.emit("exit", 1);
this.emit("close"); this.emit("close");

5
packages/protocol/src/browser/modules/fs.ts
View File

@ -6,6 +6,7 @@ import { FsModuleProxy, Stats as IStats, WatcherProxy, WriteStreamProxy } from "
import { Writable } from "./stream"; import { Writable } from "./stream";
// tslint:disable no-any // tslint:disable no-any
// tslint:disable completed-docs
class StatBatch extends Batch<IStats, { path: fs.PathLike }> { class StatBatch extends Batch<IStats, { path: fs.PathLike }> {
public constructor(private readonly proxy: FsModuleProxy) { public constructor(private readonly proxy: FsModuleProxy) {
@ -39,7 +40,7 @@ class ReaddirBatch extends Batch<Buffer[] | fs.Dirent[] | string[], { path: fs.P
class Watcher extends ClientProxy<WatcherProxy> implements fs.FSWatcher { class Watcher extends ClientProxy<WatcherProxy> implements fs.FSWatcher {
public close(): void { public close(): void {
this.proxy.close(); this.catch(this.proxy.close());
} }
protected handleDisconnect(): void { protected handleDisconnect(): void {
@ -57,7 +58,7 @@ class WriteStream extends Writable<WriteStreamProxy> implements fs.WriteStream {
} }
public close(): void { public close(): void {
this.proxy.close(); this.catch(this.proxy.close());
} }
} }

32
packages/protocol/src/browser/modules/net.ts
View File

@ -4,6 +4,8 @@ import { ClientProxy } from "../../common/proxy";
import { NetModuleProxy, NetServerProxy, NetSocketProxy } from "../../node/modules/net"; import { NetModuleProxy, NetServerProxy, NetSocketProxy } from "../../node/modules/net";
import { Duplex } from "./stream"; import { Duplex } from "./stream";
// tslint:disable completed-docs
export class Socket extends Duplex<NetSocketProxy> implements net.Socket { export class Socket extends Duplex<NetSocketProxy> implements net.Socket {
private _connecting: boolean = false; private _connecting: boolean = false;
private _destroyed: boolean = false; private _destroyed: boolean = false;
@ -29,9 +31,8 @@ export class Socket extends Duplex<NetSocketProxy> implements net.Socket {
if (callback) { if (callback) {
this.on("connect", callback as () => void); this.on("connect", callback as () => void);
} }
this.proxy.connect(options, host);
return this; return this.catch(this.proxy.connect(options, host));
} }
// tslint:disable-next-line no-any // tslint:disable-next-line no-any
@ -117,11 +118,11 @@ export class Socket extends Duplex<NetSocketProxy> implements net.Socket {
} }
public unref(): void { public unref(): void {
this.proxy.unref(); this.catch(this.proxy.unref());
} }
public ref(): void { public ref(): void {
this.proxy.ref(); this.catch(this.proxy.ref());
} }
} }
@ -133,14 +134,14 @@ export class Server extends ClientProxy<NetServerProxy> implements net.Server {
public constructor(proxyPromise: Promise<NetServerProxy> | NetServerProxy) { public constructor(proxyPromise: Promise<NetServerProxy> | NetServerProxy) {
super(proxyPromise); super(proxyPromise);
this.proxy.onConnection((socketProxy) => { this.catch(this.proxy.onConnection((socketProxy) => {
const socket = new Socket(socketProxy); const socket = new Socket(socketProxy);
const socketId = this.socketId++; const socketId = this.socketId++;
this.sockets.set(socketId, socket); this.sockets.set(socketId, socket);
socket.on("error", () => this.sockets.delete(socketId)) socket.on("error", () => this.sockets.delete(socketId));
socket.on("close", () => this.sockets.delete(socketId)) socket.on("close", () => this.sockets.delete(socketId));
this.emit("connection", socket); this.emit("connection", socket);
}); }));
this.on("listening", () => this._listening = true); this.on("listening", () => this._listening = true);
this.on("error", () => this._listening = false); this.on("error", () => this._listening = false);
@ -160,9 +161,7 @@ export class Server extends ClientProxy<NetServerProxy> implements net.Server {
this.on("listening", callback as () => void); this.on("listening", callback as () => void);
} }
this.proxy.listen(handle, hostname, backlog); return this.catch(this.proxy.listen(handle, hostname, backlog));
return this;
} }
public get connections(): number { public get connections(): number {
@ -186,21 +185,16 @@ export class Server extends ClientProxy<NetServerProxy> implements net.Server {
if (callback) { if (callback) {
this.on("close", callback); this.on("close", callback);
} }
this.proxy.close();
return this; return this.catch(this.proxy.close());
} }
public ref(): this { public ref(): this {
this.proxy.ref(); return this.catch(this.proxy.ref());
return this;
} }
public unref(): this { public unref(): this {
this.proxy.unref(); return this.catch(this.proxy.unref());
return this;
} }
public getConnections(cb: (error: Error | null, count: number) => void): void { public getConnections(cb: (error: Error | null, count: number) => void): void {

14
packages/protocol/src/browser/modules/node-pty.ts
View File

@ -2,6 +2,8 @@ import * as pty from "node-pty";
import { ClientProxy } from "../../common/proxy"; import { ClientProxy } from "../../common/proxy";
import { NodePtyModuleProxy, NodePtyProcessProxy } from "../../node/modules/node-pty"; import { NodePtyModuleProxy, NodePtyProcessProxy } from "../../node/modules/node-pty";
// tslint:disable completed-docs
export class NodePtyProcess extends ClientProxy<NodePtyProcessProxy> implements pty.IPty { export class NodePtyProcess extends ClientProxy<NodePtyProcessProxy> implements pty.IPty {
private _pid = -1; private _pid = -1;
private _process = ""; private _process = "";
@ -16,10 +18,10 @@ export class NodePtyProcess extends ClientProxy<NodePtyProcessProxy> implements
this.on("process", (process) => this._process = process); this.on("process", (process) => this._process = process);
} }
protected initialize(proxyPromise: Promise<NodePtyProcessProxy>) { protected initialize(proxyPromise: Promise<NodePtyProcessProxy>): void {
super.initialize(proxyPromise); super.initialize(proxyPromise);
this.proxy.getPid().then((pid) => this._pid = pid); this.catch(this.proxy.getPid().then((p) => this._pid = p));
this.proxy.getProcess().then((process) => this._process = process); this.catch(this.proxy.getProcess().then((p) => this._process = p));
} }
public get pid(): number { public get pid(): number {
@ -31,15 +33,15 @@ export class NodePtyProcess extends ClientProxy<NodePtyProcessProxy> implements
} }
public resize(columns: number, rows: number): void { public resize(columns: number, rows: number): void {
this.proxy.resize(columns, rows); this.catch(this.proxy.resize(columns, rows));
} }
public write(data: string): void { public write(data: string): void {
this.proxy.write(data); this.catch(this.proxy.write(data));
} }
public kill(signal?: string): void { public kill(signal?: string): void {
this.proxy.kill(signal); this.catch(this.proxy.kill(signal));
} }
protected handleDisconnect(): void { protected handleDisconnect(): void {

26
packages/protocol/src/browser/modules/spdlog.ts
View File

@ -2,6 +2,8 @@ import * as spdlog from "spdlog";
import { ClientProxy } from "../../common/proxy"; import { ClientProxy } from "../../common/proxy";
import { RotatingLoggerProxy, SpdlogModuleProxy } from "../../node/modules/spdlog"; import { RotatingLoggerProxy, SpdlogModuleProxy } from "../../node/modules/spdlog";
// tslint:disable completed-docs
class RotatingLogger extends ClientProxy<RotatingLoggerProxy> implements spdlog.RotatingLogger { class RotatingLogger extends ClientProxy<RotatingLoggerProxy> implements spdlog.RotatingLogger {
public constructor( public constructor(
private readonly moduleProxy: SpdlogModuleProxy, private readonly moduleProxy: SpdlogModuleProxy,
@ -13,16 +15,16 @@ class RotatingLogger extends ClientProxy<RotatingLoggerProxy> implements spdlog.
super(moduleProxy.createLogger(name, filename, filesize, filecount)); super(moduleProxy.createLogger(name, filename, filesize, filecount));
} }
public async trace (message: string): Promise<void> { this.proxy.trace(message); } public trace (message: string): void { this.catch(this.proxy.trace(message)); }
public async debug (message: string): Promise<void> { this.proxy.debug(message); } public debug (message: string): void { this.catch(this.proxy.debug(message)); }
public async info (message: string): Promise<void> { this.proxy.info(message); } public info (message: string): void { this.catch(this.proxy.info(message)); }
public async warn (message: string): Promise<void> { this.proxy.warn(message); } public warn (message: string): void { this.catch(this.proxy.warn(message)); }
public async error (message: string): Promise<void> { this.proxy.error(message); } public error (message: string): void { this.catch(this.proxy.error(message)); }
public async critical (message: string): Promise<void> { this.proxy.critical(message); } public critical (message: string): void { this.catch(this.proxy.critical(message)); }
public async setLevel (level: number): Promise<void> { this.proxy.setLevel(level); } public setLevel (level: number): void { this.catch(this.proxy.setLevel(level)); }
public async clearFormatters (): Promise<void> { this.proxy.clearFormatters(); } public clearFormatters (): void { this.catch(this.proxy.clearFormatters()); }
public async flush (): Promise<void> { this.proxy.flush(); } public flush (): void { this.catch(this.proxy.flush()); }
public async drop (): Promise<void> { this.proxy.drop(); } public drop (): void { this.catch(this.proxy.drop()); }
protected handleDisconnect(): void { protected handleDisconnect(): void {
this.initialize(this.moduleProxy.createLogger(this.name, this.filename, this.filesize, this.filecount)); this.initialize(this.moduleProxy.createLogger(this.name, this.filename, this.filesize, this.filecount));
@ -40,7 +42,7 @@ export class SpdlogModule {
}; };
} }
public setAsyncMode = (bufferSize: number, flushInterval: number): void => { public setAsyncMode = (bufferSize: number, flushInterval: number): Promise<void> => {
this.proxy.setAsyncMode(bufferSize, flushInterval); return this.proxy.setAsyncMode(bufferSize, flushInterval);
} }
} }

18
packages/protocol/src/browser/modules/stream.ts
View File

@ -3,6 +3,8 @@ import { callbackify } from "util";
import { ClientProxy } from "../../common/proxy"; import { ClientProxy } from "../../common/proxy";
import { DuplexProxy, IReadableProxy, WritableProxy } from "../../node/modules/stream"; import { DuplexProxy, IReadableProxy, WritableProxy } from "../../node/modules/stream";
// tslint:disable completed-docs
export class Writable<T extends WritableProxy = WritableProxy> extends ClientProxy<T> implements stream.Writable { export class Writable<T extends WritableProxy = WritableProxy> extends ClientProxy<T> implements stream.Writable {
public get writable(): boolean { public get writable(): boolean {
throw new Error("not implemented"); throw new Error("not implemented");
@ -41,13 +43,11 @@ export class Writable<T extends WritableProxy = WritableProxy> extends ClientPro
} }
public destroy(): void { public destroy(): void {
this.proxy.destroy(); this.catch(this.proxy.destroy());
} }
public setDefaultEncoding(encoding: string): this { public setDefaultEncoding(encoding: string): this {
this.proxy.setDefaultEncoding(encoding); return this.catch(this.proxy.setDefaultEncoding(encoding));
return this;
} }
// tslint:disable-next-line no-any // tslint:disable-next-line no-any
@ -151,13 +151,11 @@ export class Readable<T extends IReadableProxy = IReadableProxy> extends ClientP
} }
public destroy(): void { public destroy(): void {
this.proxy.destroy(); this.catch(this.proxy.destroy());
} }
public setEncoding(encoding: string): this { public setEncoding(encoding: string): this {
this.proxy.setEncoding(encoding); return this.catch(this.proxy.setEncoding(encoding));
return this;
} }
protected handleDisconnect(): void { protected handleDisconnect(): void {
@ -236,9 +234,7 @@ export class Duplex<T extends DuplexProxy = DuplexProxy> extends Writable<T> imp
} }
public setEncoding(encoding: string): this { public setEncoding(encoding: string): this {
this.proxy.setEncoding(encoding); return this.catch(this.proxy.setEncoding(encoding));
return this;
} }
protected handleDisconnect(): void { protected handleDisconnect(): void {

2
packages/protocol/src/browser/modules/trash.ts
View File

@ -1,6 +1,8 @@
import * as trash from "trash"; import * as trash from "trash";
import { TrashModuleProxy } from "../../node/modules/trash"; import { TrashModuleProxy } from "../../node/modules/trash";
// tslint:disable completed-docs
export class TrashModule { export class TrashModule {
public constructor(private readonly proxy: TrashModuleProxy) {} public constructor(private readonly proxy: TrashModuleProxy) {}

44
packages/protocol/src/common/proxy.ts
View File

@ -61,16 +61,34 @@ export abstract class ClientProxy<T extends ServerProxy> extends EventEmitter {
return this._proxy; return this._proxy;
} }
/**
* Initialize the proxy by unpromisifying if necessary and binding to its
* events.
*/
protected initialize(proxyPromise: Promise<T> | T): void { protected initialize(proxyPromise: Promise<T> | T): void {
this._proxy = isPromise(proxyPromise) ? unpromisify(proxyPromise) : proxyPromise; this._proxy = isPromise(proxyPromise) ? unpromisify(proxyPromise) : proxyPromise;
if (this.bindEvents) { if (this.bindEvents) {
this.proxy.onEvent((event, ...args): void => { this.catch(this.proxy.onEvent((event, ...args): void => {
this.emit(event, ...args); this.emit(event, ...args);
}); }));
} }
} }
/**
* Perform necessary cleanup on disconnect (or reconnect).
*/
protected abstract handleDisconnect(): void; protected abstract handleDisconnect(): void;
/**
* Emit an error event if the promise errors.
*/
protected catch(promise?: Promise<any>): this {
if (promise) {
promise.catch((e) => this.emit("error", e));
}
return this;
}
} }
/** /**
@ -81,6 +99,9 @@ export abstract class ClientProxy<T extends ServerProxy> extends EventEmitter {
* from those child proxies and fail to dispose them properly. * from those child proxies and fail to dispose them properly.
*/ */
export interface ServerProxy { export interface ServerProxy {
/**
* Dispose the proxy.
*/
dispose(): Promise<void>; dispose(): Promise<void>;
/** /**
@ -100,6 +121,9 @@ export interface ServerProxy {
onEvent(cb: (event: string, ...args: any[]) => void): Promise<void>; onEvent(cb: (event: string, ...args: any[]) => void): Promise<void>;
} }
/**
* Supported top-level module proxies.
*/
export enum Module { export enum Module {
Fs = "fs", Fs = "fs",
ChildProcess = "child_process", ChildProcess = "child_process",
@ -127,19 +151,19 @@ export abstract class Batch<T, A> {
/** /**
* Flush after reaching this amount of time. * Flush after reaching this amount of time.
*/ */
private readonly maxTime = 1000, private readonly maxTime: number = 1000,
/** /**
* Flush after reaching this count. * Flush after reaching this count.
*/ */
private readonly maxCount = 100, private readonly maxCount: number = 100,
/** /**
* Flush after not receiving more requests for this amount of time. * Flush after not receiving more requests for this amount of time.
*/ */
private readonly idleTime = 100, private readonly idleTime: number = 100,
) {} ) {}
public add = (args: A): Promise<T> => { public add = (args: A): Promise<T> => {
return new Promise((resolve, reject) => { return new Promise((resolve, reject): void => {
this.batch.push({ this.batch.push({
args, args,
resolve, resolve,
@ -157,9 +181,15 @@ export abstract class Batch<T, A> {
}); });
} }
/**
* Perform remote call for a batch.
*/
protected abstract remoteCall(batch: A[]): Promise<(T | Error)[]>; protected abstract remoteCall(batch: A[]): Promise<(T | Error)[]>;
private flush = (): void => { /**
* Flush out the current batch.
*/
private readonly flush = (): void => {
clearTimeout(this.idleTimeout as any); clearTimeout(this.idleTimeout as any);
clearTimeout(this.maxTimeout as any); clearTimeout(this.maxTimeout as any);
this.maxTimeout = undefined; this.maxTimeout = undefined;

283
packages/protocol/src/common/util.ts
View File

@ -1,4 +1,4 @@
import { Module as ProtoModule, WorkingInitMessage } from "../proto"; import { Argument, Module as ProtoModule, WorkingInit } from "../proto";
import { OperatingSystem } from "../common/connection"; import { OperatingSystem } from "../common/connection";
import { Module, ServerProxy } from "./proxy"; import { Module, ServerProxy } from "./proxy";
@ -29,227 +29,144 @@ export type IEncodingOptions = {
export type IEncodingOptionsCallback = IEncodingOptions | ((err: NodeJS.ErrnoException, ...args: any[]) => void); export type IEncodingOptionsCallback = IEncodingOptions | ((err: NodeJS.ErrnoException, ...args: any[]) => void);
interface StringifiedError {
type: "error";
data: {
message: string;
stack?: string;
code?: string;
};
}
interface StringifiedBuffer {
type: "buffer";
data: number[];
}
interface StringifiedObject {
type: "object";
data: { [key: string]: StringifiedValue };
}
interface StringifiedArray {
type: "array";
data: StringifiedValue[];
}
interface StringifiedProxy {
type: "proxy";
data: {
id: number;
};
}
interface StringifiedFunction {
type: "function";
data: {
id: number;
};
}
interface StringifiedUndefined {
type: "undefined";
}
type StringifiedValue = StringifiedFunction | StringifiedProxy
| StringifiedUndefined | StringifiedObject | StringifiedArray
| StringifiedBuffer | StringifiedError | number | string | boolean | null;
const isPrimitive = (value: any): value is number | string | boolean | null => {
return typeof value === "number"
|| typeof value === "string"
|| typeof value === "boolean"
|| value === null;
};
/** /**
* Stringify an argument or a return value. * Convert an argument to proto.
* If sending a function is possible, provide `storeFunction`. * If sending a function is possible, provide `storeFunction`.
* If sending a proxy is possible, provide `storeProxy`. * If sending a proxy is possible, provide `storeProxy`.
*/ */
export const stringify = ( export const argumentToProto = (
value: any, value: any,
storeFunction?: (fn: () => void) => number, storeFunction?: (fn: () => void) => number,
storeProxy?: (proxy: ServerProxy) => number, storeProxy?: (proxy: ServerProxy) => number,
): string => { ): Argument => {
const convert = (currentValue: any): StringifiedValue => { const convert = (currentValue: any): Argument => {
// Errors don't stringify at all. They just become "{}". const message = new Argument();
// For some reason when running in Jest errors aren't instances of Error,
// so also check against the values.
if (currentValue instanceof Error if (currentValue instanceof Error
|| (currentValue && typeof currentValue.message !== "undefined" || (currentValue && typeof currentValue.message !== "undefined"
&& typeof currentValue.stack !== "undefined")) { && typeof currentValue.stack !== "undefined")) {
return { const arg = new Argument.ErrorValue();
type: "error", arg.setMessage(currentValue.message);
data: { arg.setStack(currentValue.stack);
message: currentValue.message, arg.setCode(currentValue.code);
stack: currentValue.stack, message.setError(arg);
code: (currentValue as NodeJS.ErrnoException).code, } else if (currentValue instanceof Uint8Array || currentValue instanceof Buffer) {
}, const arg = new Argument.BufferValue();
}; arg.setData(currentValue);
} message.setBuffer(arg);
} else if (Array.isArray(currentValue)) {
// With stringify, Uint8Array gets turned into objects with each index const arg = new Argument.ArrayValue();
// becoming a key for some reason. Then trying to do something like write arg.setDataList(currentValue.map(convert));
// that data results in [object Object] being written. Stringify them like message.setArray(arg);
// a Buffer instead. Also handle Buffer so it doesn't get caught by the } else if (isProxy(currentValue)) {
// object check and to get the same type.
if (currentValue instanceof Uint8Array || currentValue instanceof Buffer) {
return {
type: "buffer",
data: Array.from(currentValue),
};
}
if (Array.isArray(currentValue)) {
return {
type: "array",
data: currentValue.map((a) => convert(a)),
};
}
if (isProxy(currentValue)) {
if (!storeProxy) { if (!storeProxy) {
throw new Error("no way to serialize proxy"); throw new Error("no way to serialize proxy");
} }
const arg = new Argument.ProxyValue();
return { arg.setId(storeProxy(currentValue));
type: "proxy", message.setProxy(arg);
data: { } else if (currentValue !== null && typeof currentValue === "object") {
id: storeProxy(currentValue), const arg = new Argument.ObjectValue();
}, const map = arg.getDataMap();
};
}
if (currentValue !== null && typeof currentValue === "object") {
const converted: { [key: string]: StringifiedValue } = {};
Object.keys(currentValue).forEach((key) => { Object.keys(currentValue).forEach((key) => {
converted[key] = convert(currentValue[key]); map.set(key, convert(currentValue[key]));
}); });
message.setObject(arg);
return { } else if (currentValue === null) {
type: "object", message.setNull(new Argument.NullValue());
data: converted, } else {
}; switch (typeof currentValue) {
} case "undefined":
message.setUndefined(new Argument.UndefinedValue());
// `undefined` can't be stringified. break;
if (typeof currentValue === "undefined") { case "function":
return {
type: "undefined",
};
}
if (typeof currentValue === "function") {
if (!storeFunction) { if (!storeFunction) {
throw new Error("no way to serialize function"); throw new Error("no way to serialize function");
} }
const arg = new Argument.FunctionValue();
return { arg.setId(storeFunction(currentValue));
type: "function", message.setFunction(arg);
data: { break;
id: storeFunction(currentValue), case "number":
}, message.setNumber(currentValue);
}; break;
case "string":
message.setString(currentValue);
break;
case "boolean":
message.setBoolean(currentValue);
break;
default:
throw new Error(`cannot convert ${typeof currentValue} to proto`);
}
} }
if (!isPrimitive(currentValue)) { return message;
throw new Error(`cannot stringify ${typeof currentValue}`);
}
return currentValue;
}; };
return JSON.stringify(convert(value)); return convert(value);
}; };
/** /**
* Parse an argument. * Convert proto to an argument.
* If running a remote callback is supported, provide `runCallback`. * If running a remote callback is supported, provide `runCallback`.
* If using a remote proxy is supported, provide `createProxy`. * If using a remote proxy is supported, provide `createProxy`.
*/ */
export const parse = ( export const protoToArgument = (
value?: string, message?: Argument,
runCallback?: (id: number, args: any[]) => void, runCallback?: (id: number, args: any[]) => void,
createProxy?: (id: number) => ServerProxy, createProxy?: (id: number) => ServerProxy,
): any => { ): any => {
const convert = (currentValue: StringifiedValue): any => { const convert = (currentMessage: Argument): any => {
if (currentValue && !isPrimitive(currentValue)) { switch (currentMessage.getMsgCase()) {
// Would prefer a switch but the types don't seem to work. case Argument.MsgCase.ERROR:
if (currentValue.type === "buffer") { const errorMessage = currentMessage.getError()!;
return Buffer.from(currentValue.data); const error = new Error(errorMessage.getMessage());
} (error as NodeJS.ErrnoException).code = errorMessage.getCode();
(error as any).originalStack = errorMessage.getStack();
if (currentValue.type === "error") {
const error = new Error(currentValue.data.message);
if (typeof currentValue.data.code !== "undefined") {
(error as NodeJS.ErrnoException).code = currentValue.data.code;
}
(error as any).originalStack = currentValue.data.stack;
return error; return error;
case Argument.MsgCase.BUFFER:
return Buffer.from(currentMessage.getBuffer()!.getData() as Uint8Array);
case Argument.MsgCase.ARRAY:
return currentMessage.getArray()!.getDataList().map((a) => convert(a));
case Argument.MsgCase.PROXY:
if (!createProxy) {
throw new Error("no way to create proxy");
} }
if (currentValue.type === "object") { return createProxy(currentMessage.getProxy()!.getId());
const converted: { [key: string]: any } = {}; case Argument.MsgCase.OBJECT:
Object.keys(currentValue.data).forEach((key) => { const obj: { [Key: string]: any } = {};
converted[key] = convert(currentValue.data[key]); currentMessage.getObject()!.getDataMap().forEach((argument, key) => {
obj[key] = convert(argument);
}); });
return converted; return obj;
} case Argument.MsgCase.UNDEFINED:
if (currentValue.type === "array") {
return currentValue.data.map(convert);
}
if (currentValue.type === "undefined") {
return undefined; return undefined;
} case Argument.MsgCase.NULL:
return null;
if (currentValue.type === "function") { case Argument.MsgCase.FUNCTION:
if (!runCallback) { if (!runCallback) {
throw new Error("no way to run remote callback"); throw new Error("no way to run remote callback");
} }
return (...args: any[]): void => { return (...args: any[]): void => {
return runCallback(currentValue.data.id, args); return runCallback(currentMessage.getFunction()!.getId(), args);
}; };
case Argument.MsgCase.NUMBER:
return currentMessage.getNumber();
case Argument.MsgCase.STRING:
return currentMessage.getString();
case Argument.MsgCase.BOOLEAN:
return currentMessage.getBoolean();
default:
throw new Error("cannot convert unexpected proto to argument");
} }
if (currentValue.type === "proxy") {
if (!createProxy) {
throw new Error("no way to create proxy");
}
return createProxy(currentValue.data.id);
}
}
return currentValue;
}; };
return value && convert(JSON.parse(value)); return message && convert(message);
}; };
export const protoToModule = (protoModule: ProtoModule): Module => { export const protoToModule = (protoModule: ProtoModule): Module => {
@ -276,20 +193,20 @@ export const moduleToProto = (moduleName: Module): ProtoModule => {
} }
}; };
export const protoToOperatingSystem = (protoOp: WorkingInitMessage.OperatingSystem): OperatingSystem => { export const protoToOperatingSystem = (protoOp: WorkingInit.OperatingSystem): OperatingSystem => {
switch (protoOp) { switch (protoOp) {
case WorkingInitMessage.OperatingSystem.WINDOWS: return OperatingSystem.Windows; case WorkingInit.OperatingSystem.WINDOWS: return OperatingSystem.Windows;
case WorkingInitMessage.OperatingSystem.LINUX: return OperatingSystem.Linux; case WorkingInit.OperatingSystem.LINUX: return OperatingSystem.Linux;
case WorkingInitMessage.OperatingSystem.MAC: return OperatingSystem.Mac; case WorkingInit.OperatingSystem.MAC: return OperatingSystem.Mac;
default: throw new Error(`unsupported operating system ${protoOp}`); default: throw new Error(`unsupported operating system ${protoOp}`);
} }
}; };
export const platformToProto = (platform: NodeJS.Platform): WorkingInitMessage.OperatingSystem => { export const platformToProto = (platform: NodeJS.Platform): WorkingInit.OperatingSystem => {
switch (platform) { switch (platform) {
case "win32": return WorkingInitMessage.OperatingSystem.WINDOWS; case "win32": return WorkingInit.OperatingSystem.WINDOWS;
case "linux": return WorkingInitMessage.OperatingSystem.LINUX; case "linux": return WorkingInit.OperatingSystem.LINUX;
case "darwin": return WorkingInitMessage.OperatingSystem.MAC; case "darwin": return WorkingInit.OperatingSystem.MAC;
default: throw new Error(`unrecognized platform "${platform}"`); default: throw new Error(`unrecognized platform "${platform}"`);
} }
}; };

14
packages/protocol/src/node/modules/child_process.ts
View File

@ -3,6 +3,8 @@ import { ServerProxy } from "../../common/proxy";
import { preserveEnv } from "../../common/util"; import { preserveEnv } from "../../common/util";
import { WritableProxy, ReadableProxy } from "./stream"; import { WritableProxy, ReadableProxy } from "./stream";
// tslint:disable completed-docs
export type ForkProvider = (modulePath: string, args?: string[], options?: cp.ForkOptions) => cp.ChildProcess; export type ForkProvider = (modulePath: string, args?: string[], options?: cp.ForkOptions) => cp.ChildProcess;
export class ChildProcessProxy implements ServerProxy { export class ChildProcessProxy implements ServerProxy {
@ -26,7 +28,7 @@ export class ChildProcessProxy implements ServerProxy {
// tslint:disable-next-line no-any // tslint:disable-next-line no-any
public async send(message: any): Promise<void> { public async send(message: any): Promise<void> {
return new Promise((resolve, reject) => { return new Promise((resolve, reject): void => {
this.process.send(message, (error) => { this.process.send(message, (error) => {
if (error) { if (error) {
reject(error); reject(error);
@ -46,8 +48,8 @@ export class ChildProcessProxy implements ServerProxy {
} }
public async dispose(): Promise<void> { public async dispose(): Promise<void> {
this.kill(); this.process.kill();
setTimeout(() => this.kill("SIGKILL"), 5000); // Double tap. setTimeout(() => this.process.kill("SIGKILL"), 5000); // Double tap.
} }
// tslint:disable-next-line no-any // tslint:disable-next-line no-any
@ -62,9 +64,9 @@ export class ChildProcessProxy implements ServerProxy {
export interface ChildProcessProxies { export interface ChildProcessProxies {
childProcess: ChildProcessProxy; childProcess: ChildProcessProxy;
stdin?: WritableProxy; stdin?: WritableProxy | null;
stdout?: ReadableProxy; stdout?: ReadableProxy | null;
stderr?: ReadableProxy; stderr?: ReadableProxy | null;
} }
export class ChildProcessModuleProxy { export class ChildProcessModuleProxy {

10
packages/protocol/src/node/modules/fs.ts
View File

@ -4,6 +4,8 @@ import { ServerProxy } from "../../common/proxy";
import { IEncodingOptions } from "../../common/util"; import { IEncodingOptions } from "../../common/util";
import { WritableProxy } from "./stream"; import { WritableProxy } from "./stream";
// tslint:disable completed-docs
/** /**
* A serializable version of fs.Stats. * A serializable version of fs.Stats.
*/ */
@ -41,13 +43,13 @@ export class WriteStreamProxy extends WritableProxy<fs.WriteStream> {
} }
public async dispose(): Promise<void> { public async dispose(): Promise<void> {
super.dispose(); await super.dispose();
this.stream.close(); this.stream.close();
} }
// tslint:disable-next-line no-any // tslint:disable-next-line no-any
public async onEvent(cb: (event: string, ...args: any[]) => void): Promise<void> { public async onEvent(cb: (event: string, ...args: any[]) => void): Promise<void> {
super.onEvent(cb); await super.onEvent(cb);
this.stream.on("open", (fd) => cb("open", fd)); this.stream.on("open", (fd) => cb("open", fd));
} }
} }
@ -109,7 +111,7 @@ export class FsModuleProxy {
} }
public exists(path: fs.PathLike): Promise<boolean> { public exists(path: fs.PathLike): Promise<boolean> {
return promisify(fs.exists)(path); return promisify(fs.exists)(path); // tslint:disable-line deprecation
} }
public fchmod(fd: number, mode: string | number): Promise<void> { public fchmod(fd: number, mode: string | number): Promise<void> {
@ -173,7 +175,7 @@ export class FsModuleProxy {
} }
public read(fd: number, length: number, position: number | null): Promise<{ bytesRead: number, buffer: Buffer }> { public read(fd: number, length: number, position: number | null): Promise<{ bytesRead: number, buffer: Buffer }> {
const buffer = new Buffer(length); const buffer = Buffer.alloc(length);
return promisify(fs.read)(fd, buffer, 0, length, position); return promisify(fs.read)(fd, buffer, 0, length, position);
} }

4
packages/protocol/src/node/modules/net.ts
View File

@ -2,6 +2,8 @@ import * as net from "net";
import { ServerProxy } from "../../common/proxy"; import { ServerProxy } from "../../common/proxy";
import { DuplexProxy } from "./stream"; import { DuplexProxy } from "./stream";
// tslint:disable completed-docs
export class NetSocketProxy extends DuplexProxy<net.Socket> { export class NetSocketProxy extends DuplexProxy<net.Socket> {
public async connect(options: number | string | net.SocketConnectOpts, host?: string): Promise<void> { public async connect(options: number | string | net.SocketConnectOpts, host?: string): Promise<void> {
this.stream.connect(options as any, host as any); // tslint:disable-line no-any this works fine this.stream.connect(options as any, host as any); // tslint:disable-line no-any this works fine
@ -28,7 +30,7 @@ export class NetSocketProxy extends DuplexProxy<net.Socket> {
// tslint:disable-next-line no-any // tslint:disable-next-line no-any
public async onEvent(cb: (event: string, ...args: any[]) => void): Promise<void> { public async onEvent(cb: (event: string, ...args: any[]) => void): Promise<void> {
super.onEvent(cb); await super.onEvent(cb);
this.stream.on("connect", () => cb("connect")); this.stream.on("connect", () => cb("connect"));
this.stream.on("lookup", (error, address, family, host) => cb("lookup", error, address, family, host)); this.stream.on("lookup", (error, address, family, host) => cb("lookup", error, address, family, host));
this.stream.on("timeout", () => cb("timeout")); this.stream.on("timeout", () => cb("timeout"));

8
packages/protocol/src/node/modules/node-pty.ts
View File

@ -4,6 +4,8 @@ import * as pty from "node-pty";
import { ServerProxy } from "../../common/proxy"; import { ServerProxy } from "../../common/proxy";
import { preserveEnv } from "../../common/util"; import { preserveEnv } from "../../common/util";
// tslint:disable completed-docs
/** /**
* Server-side IPty proxy. * Server-side IPty proxy.
*/ */
@ -22,7 +24,7 @@ export class NodePtyProcessProxy implements ServerProxy {
} }
}, 200); }, 200);
this.onDone(() => clearInterval(timer)); this.process.on("exit", () => clearInterval(timer));
} }
public async getPid(): Promise<number> { public async getPid(): Promise<number> {
@ -50,8 +52,8 @@ export class NodePtyProcessProxy implements ServerProxy {
} }
public async dispose(): Promise<void> { public async dispose(): Promise<void> {
this.kill(); this.process.kill();
setTimeout(() => this.kill("SIGKILL"), 5000); // Double tap. setTimeout(() => this.process.kill("SIGKILL"), 5000); // Double tap.
this.emitter.removeAllListeners(); this.emitter.removeAllListeners();
} }

4
packages/protocol/src/node/modules/spdlog.ts
View File

@ -3,6 +3,8 @@ import { EventEmitter } from "events";
import * as spdlog from "spdlog"; import * as spdlog from "spdlog";
import { ServerProxy } from "../../common/proxy"; import { ServerProxy } from "../../common/proxy";
// tslint:disable completed-docs
export class RotatingLoggerProxy implements ServerProxy { export class RotatingLoggerProxy implements ServerProxy {
private readonly emitter = new EventEmitter(); private readonly emitter = new EventEmitter();
@ -24,7 +26,7 @@ export class RotatingLoggerProxy implements ServerProxy {
} }
public async dispose(): Promise<void> { public async dispose(): Promise<void> {
this.flush(); await this.flush();
this.emitter.emit("dispose"); this.emitter.emit("dispose");
this.emitter.removeAllListeners(); this.emitter.removeAllListeners();
} }

4
packages/protocol/src/node/modules/stream.ts
View File

@ -1,6 +1,8 @@
import * as stream from "stream"; import * as stream from "stream";
import { ServerProxy } from "../../common/proxy"; import { ServerProxy } from "../../common/proxy";
// tslint:disable completed-docs
export class WritableProxy<T extends stream.Writable = stream.Writable> implements ServerProxy { export class WritableProxy<T extends stream.Writable = stream.Writable> implements ServerProxy {
public constructor(protected readonly stream: T) {} public constructor(protected readonly stream: T) {}
@ -100,7 +102,7 @@ export class DuplexProxy<T extends stream.Duplex = stream.Duplex> extends Writab
// tslint:disable-next-line no-any // tslint:disable-next-line no-any
public async onEvent(cb: (event: string, ...args: any[]) => void): Promise<void> { public async onEvent(cb: (event: string, ...args: any[]) => void): Promise<void> {
super.onEvent(cb); await super.onEvent(cb);
this.stream.on("data", (chunk) => cb("data", chunk)); this.stream.on("data", (chunk) => cb("data", chunk));
this.stream.on("end", () => cb("end")); this.stream.on("end", () => cb("end"));
} }

2
packages/protocol/src/node/modules/trash.ts
View File

@ -1,5 +1,7 @@
import * as trash from "trash"; import * as trash from "trash";
// tslint:disable completed-docs
export class TrashModuleProxy { export class TrashModuleProxy {
public async trash(path: string, options?: trash.Options): Promise<void> { public async trash(path: string, options?: trash.Options): Promise<void> {
return trash(path, options); return trash(path, options);

101
packages/protocol/src/node/server.ts
View File

@ -3,8 +3,8 @@ import * as os from "os";
import { field, logger} from "@coder/logger"; import { field, logger} from "@coder/logger";
import { ReadWriteConnection } from "../common/connection"; import { ReadWriteConnection } from "../common/connection";
import { Module, ServerProxy } from "../common/proxy"; import { Module, ServerProxy } from "../common/proxy";
import { isPromise, isProxy, moduleToProto, parse, platformToProto, protoToModule, stringify } from "../common/util"; import { isPromise, isProxy, moduleToProto, protoToArgument, platformToProto, protoToModule, argumentToProto } from "../common/util";
import { CallbackMessage, ClientMessage, EventMessage, FailMessage, MethodMessage, NamedCallbackMessage, NamedEventMessage, NumberedCallbackMessage, NumberedEventMessage, Pong, ServerMessage, SuccessMessage, WorkingInitMessage } from "../proto"; import { Argument, Callback, ClientMessage, Event, Method, Pong, ServerMessage, WorkingInit } from "../proto";
import { ChildProcessModuleProxy, ForkProvider, FsModuleProxy, NetModuleProxy, NodePtyModuleProxy, SpdlogModuleProxy, TrashModuleProxy } from "./modules"; import { ChildProcessModuleProxy, ForkProvider, FsModuleProxy, NetModuleProxy, NodePtyModuleProxy, SpdlogModuleProxy, TrashModuleProxy } from "./modules";
// tslint:disable no-any // tslint:disable no-any
@ -22,11 +22,14 @@ interface ProxyData {
instance: any; instance: any;
} }
/**
* Handle messages from the client.
*/
export class Server { export class Server {
private proxyId = 0; private proxyId = 0;
private readonly proxies = new Map<number | Module, ProxyData>(); private readonly proxies = new Map<number | Module, ProxyData>();
private disconnected: boolean = false; private disconnected: boolean = false;
private responseTimeout = 10000; private readonly responseTimeout = 10000;
public constructor( public constructor(
private readonly connection: ReadWriteConnection, private readonly connection: ReadWriteConnection,
@ -57,7 +60,9 @@ export class Server {
this.proxies.forEach((proxy, proxyId) => { this.proxies.forEach((proxy, proxyId) => {
if (isProxy(proxy.instance)) { if (isProxy(proxy.instance)) {
proxy.instance.dispose(); proxy.instance.dispose().catch((error) => {
logger.error(error.message);
});
} }
this.removeProxy(proxyId); this.removeProxy(proxyId);
}); });
@ -84,14 +89,14 @@ export class Server {
logger.error(error.message, field("error", error)); logger.error(error.message, field("error", error));
}); });
const initMsg = new WorkingInitMessage(); const initMsg = new WorkingInit();
initMsg.setDataDirectory(this.options.dataDirectory); initMsg.setDataDirectory(this.options.dataDirectory);
initMsg.setWorkingDirectory(this.options.workingDirectory); initMsg.setWorkingDirectory(this.options.workingDirectory);
initMsg.setBuiltinExtensionsDir(this.options.builtInExtensionsDirectory); initMsg.setBuiltinExtensionsDir(this.options.builtInExtensionsDirectory);
initMsg.setHomeDirectory(os.homedir()); initMsg.setHomeDirectory(os.homedir());
initMsg.setTmpDirectory(os.tmpdir()); initMsg.setTmpDirectory(os.tmpdir());
initMsg.setOperatingSystem(platformToProto(os.platform())); initMsg.setOperatingSystem(platformToProto(os.platform()));
initMsg.setShell(os.userInfo().shell || global.process.env.SHELL); initMsg.setShell(os.userInfo().shell || global.process.env.SHELL || "");
const srvMsg = new ServerMessage(); const srvMsg = new ServerMessage();
srvMsg.setInit(initMsg); srvMsg.setInit(initMsg);
connection.send(srvMsg.serializeBinary()); connection.send(srvMsg.serializeBinary());
@ -101,14 +106,17 @@ export class Server {
* Handle all messages from the client. * Handle all messages from the client.
*/ */
private async handleMessage(message: ClientMessage): Promise<void> { private async handleMessage(message: ClientMessage): Promise<void> {
if (message.hasMethod()) { switch (message.getMsgCase()) {
case ClientMessage.MsgCase.METHOD:
await this.runMethod(message.getMethod()!); await this.runMethod(message.getMethod()!);
} else if (message.hasPing()) { break;
case ClientMessage.MsgCase.PING:
logger.trace("ping"); logger.trace("ping");
const srvMsg = new ServerMessage(); const srvMsg = new ServerMessage();
srvMsg.setPong(new Pong()); srvMsg.setPong(new Pong());
this.connection.send(srvMsg.serializeBinary()); this.connection.send(srvMsg.serializeBinary());
} else { break;
default:
throw new Error("unknown message type"); throw new Error("unknown message type");
} }
} }
@ -116,14 +124,14 @@ export class Server {
/** /**
* Run a method on a proxy. * Run a method on a proxy.
*/ */
private async runMethod(message: MethodMessage): Promise<void> { private async runMethod(message: Method): Promise<void> {
const proxyMessage = message.getNamedProxy()! || message.getNumberedProxy()!; const proxyMessage = message.getNamedProxy()! || message.getNumberedProxy()!;
const id = proxyMessage.getId(); const id = proxyMessage.getId();
const proxyId = message.hasNamedProxy() const proxyId = message.hasNamedProxy()
? protoToModule(message.getNamedProxy()!.getModule()) ? protoToModule(message.getNamedProxy()!.getModule())
: message.getNumberedProxy()!.getProxyId(); : message.getNumberedProxy()!.getProxyId();
const method = proxyMessage.getMethod(); const method = proxyMessage.getMethod();
const args = proxyMessage.getArgsList().map((a) => parse( const args = proxyMessage.getArgsList().map((a) => protoToArgument(
a, a,
(id, args) => this.sendCallback(proxyId, id, args), (id, args) => this.sendCallback(proxyId, id, args),
)); ));
@ -133,7 +141,6 @@ export class Server {
field("id", id), field("id", id),
field("proxyId", proxyId), field("proxyId", proxyId),
field("method", method), field("method", method),
field("args", proxyMessage.getArgsList()),
]); ]);
let response: any; let response: any;
@ -153,7 +160,7 @@ export class Server {
// Proxies must always return promises. // Proxies must always return promises.
if (!isPromise(response)) { if (!isPromise(response)) {
throw new Error('"${method}" must return a promise'); throw new Error(`"${method}" must return a promise`);
} }
} catch (error) { } catch (error) {
logger.error( logger.error(
@ -175,27 +182,25 @@ export class Server {
* Send a callback to the client. * Send a callback to the client.
*/ */
private sendCallback(proxyId: number | Module, callbackId: number, args: any[]): void { private sendCallback(proxyId: number | Module, callbackId: number, args: any[]): void {
const stringifiedArgs = args.map((a) => this.stringify(a));
logger.trace(() => [ logger.trace(() => [
"sending callback", "sending callback",
field("proxyId", proxyId), field("proxyId", proxyId),
field("callbackId", callbackId), field("callbackId", callbackId),
field("args", stringifiedArgs),
]); ]);
const message = new CallbackMessage(); const message = new Callback();
let callbackMessage: NamedCallbackMessage | NumberedCallbackMessage; let callbackMessage: Callback.Named | Callback.Numbered;
if (typeof proxyId === "string") { if (typeof proxyId === "string") {
callbackMessage = new NamedCallbackMessage(); callbackMessage = new Callback.Named();
callbackMessage.setModule(moduleToProto(proxyId)); callbackMessage.setModule(moduleToProto(proxyId));
message.setNamedCallback(callbackMessage); message.setNamedCallback(callbackMessage);
} else { } else {
callbackMessage = new NumberedCallbackMessage(); callbackMessage = new Callback.Numbered();
callbackMessage.setProxyId(proxyId); callbackMessage.setProxyId(proxyId);
message.setNumberedCallback(callbackMessage); message.setNumberedCallback(callbackMessage);
} }
callbackMessage.setCallbackId(callbackId); callbackMessage.setCallbackId(callbackId);
callbackMessage.setArgsList(stringifiedArgs); callbackMessage.setArgsList(args.map((a) => this.argumentToProto(a)));
const serverMessage = new ServerMessage(); const serverMessage = new ServerMessage();
serverMessage.setCallback(message); serverMessage.setCallback(message);
@ -203,15 +208,23 @@ export class Server {
} }
/** /**
* Store a proxy and bind events to send them back to the client. * Store a numbered proxy and bind events to send them back to the client.
*/ */
private storeProxy(instance: ServerProxy): number; private storeProxy(instance: ServerProxy): number;
/**
* Store a unique proxy and bind events to send them back to the client.
*/
private storeProxy(instance: any, moduleProxyId: Module): Module; private storeProxy(instance: any, moduleProxyId: Module): Module;
/**
* Store a proxy and bind events to send them back to the client.
*/
private storeProxy(instance: ServerProxy | any, moduleProxyId?: Module): number | Module { private storeProxy(instance: ServerProxy | any, moduleProxyId?: Module): number | Module {
// In case we disposed while waiting for a function to return. // In case we disposed while waiting for a function to return.
if (this.disconnected) { if (this.disconnected) {
if (isProxy(instance)) { if (isProxy(instance)) {
instance.dispose(); instance.dispose().catch((error) => {
logger.error(error.message);
});
} }
throw new Error("disposed"); throw new Error("disposed");
@ -226,16 +239,22 @@ export class Server {
this.proxies.set(proxyId, { instance }); this.proxies.set(proxyId, { instance });
if (isProxy(instance)) { if (isProxy(instance)) {
instance.onEvent((event, ...args) => this.sendEvent(proxyId, event, ...args)); instance.onEvent((event, ...args) => this.sendEvent(proxyId, event, ...args)).catch((error) => {
logger.error(error.message);
});
instance.onDone(() => { instance.onDone(() => {
// It might have finished because we disposed it due to a disconnect. // It might have finished because we disposed it due to a disconnect.
if (!this.disconnected) { if (!this.disconnected) {
this.sendEvent(proxyId, "done"); this.sendEvent(proxyId, "done");
this.getProxy(proxyId).disposeTimeout = setTimeout(() => { this.getProxy(proxyId).disposeTimeout = setTimeout(() => {
instance.dispose(); instance.dispose().catch((error) => {
logger.error(error.message);
});
this.removeProxy(proxyId); this.removeProxy(proxyId);
}, this.responseTimeout); }, this.responseTimeout);
} }
}).catch((error) => {
logger.error(error.message);
}); });
} }
@ -246,27 +265,25 @@ export class Server {
* Send an event to the client. * Send an event to the client.
*/ */
private sendEvent(proxyId: number | Module, event: string, ...args: any[]): void { private sendEvent(proxyId: number | Module, event: string, ...args: any[]): void {
const stringifiedArgs = args.map((a) => this.stringify(a));
logger.trace(() => [ logger.trace(() => [
"sending event", "sending event",
field("proxyId", proxyId), field("proxyId", proxyId),
field("event", event), field("event", event),
field("args", stringifiedArgs),
]); ]);
const message = new EventMessage(); const message = new Event();
let eventMessage: NamedEventMessage | NumberedEventMessage; let eventMessage: Event.Named | Event.Numbered;
if (typeof proxyId === "string") { if (typeof proxyId === "string") {
eventMessage = new NamedEventMessage(); eventMessage = new Event.Named();
eventMessage.setModule(moduleToProto(proxyId)); eventMessage.setModule(moduleToProto(proxyId));
message.setNamedEvent(eventMessage); message.setNamedEvent(eventMessage);
} else { } else {
eventMessage = new NumberedEventMessage(); eventMessage = new Event.Numbered();
eventMessage.setProxyId(proxyId); eventMessage.setProxyId(proxyId);
message.setNumberedEvent(eventMessage); message.setNumberedEvent(eventMessage);
} }
eventMessage.setEvent(event); eventMessage.setEvent(event);
eventMessage.setArgsList(stringifiedArgs); eventMessage.setArgsList(args.map((a) => this.argumentToProto(a)));
const serverMessage = new ServerMessage(); const serverMessage = new ServerMessage();
serverMessage.setEvent(message); serverMessage.setEvent(message);
@ -277,16 +294,14 @@ export class Server {
* Send a response back to the client. * Send a response back to the client.
*/ */
private sendResponse(id: number, response: any): void { private sendResponse(id: number, response: any): void {
const stringifiedResponse = this.stringify(response);
logger.trace(() => [ logger.trace(() => [
"sending resolve", "sending resolve",
field("id", id), field("id", id),
field("response", stringifiedResponse),
]); ]);
const successMessage = new SuccessMessage(); const successMessage = new Method.Success();
successMessage.setId(id); successMessage.setId(id);
successMessage.setResponse(stringifiedResponse); successMessage.setResponse(this.argumentToProto(response));
const serverMessage = new ServerMessage(); const serverMessage = new ServerMessage();
serverMessage.setSuccess(successMessage); serverMessage.setSuccess(successMessage);
@ -297,16 +312,14 @@ export class Server {
* Send an exception back to the client. * Send an exception back to the client.
*/ */
private sendException(id: number, error: Error): void { private sendException(id: number, error: Error): void {
const stringifiedError = stringify(error);
logger.trace(() => [ logger.trace(() => [
"sending reject", "sending reject",
field("id", id) , field("id", id) ,
field("response", stringifiedError),
]); ]);
const failedMessage = new FailMessage(); const failedMessage = new Method.Fail();
failedMessage.setId(id); failedMessage.setId(id);
failedMessage.setResponse(stringifiedError); failedMessage.setResponse(argumentToProto(error));
const serverMessage = new ServerMessage(); const serverMessage = new ServerMessage();
serverMessage.setFail(failedMessage); serverMessage.setFail(failedMessage);
@ -327,10 +340,16 @@ export class Server {
]); ]);
} }
private stringify(value: any): string { /**
return stringify(value, undefined, (p) => this.storeProxy(p)); * Same as argumentToProto but provides storeProxy.
*/
private argumentToProto(value: any): Argument {
return argumentToProto(value, undefined, (p) => this.storeProxy(p));
} }
/**
* Get a proxy. Error if it doesn't exist.
*/
private getProxy(proxyId: number | Module): ProxyData { private getProxy(proxyId: number | Module): ProxyData {
if (!this.proxies.has(proxyId)) { if (!this.proxies.has(proxyId)) {
throw new Error(`proxy ${proxyId} disposed too early`); throw new Error(`proxy ${proxyId} disposed too early`);

16
packages/protocol/src/proto/client.proto
View File

@ -6,7 +6,7 @@ import "vscode.proto";
message ClientMessage { message ClientMessage {
oneof msg { oneof msg {
// node.proto // node.proto
MethodMessage method = 20; Method method = 20;
Ping ping = 21; Ping ping = 21;
} }
} }
@ -15,20 +15,20 @@ message ClientMessage {
message ServerMessage { message ServerMessage {
oneof msg { oneof msg {
// node.proto // node.proto
FailMessage fail = 13; Method.Fail fail = 13;
SuccessMessage success = 14; Method.Success success = 14;
EventMessage event = 19; Event event = 19;
CallbackMessage callback = 22; Callback callback = 22;
Pong pong = 18; Pong pong = 18;
WorkingInitMessage init = 16; WorkingInit init = 16;
// vscode.proto // vscode.proto
SharedProcessActiveMessage shared_process_active = 17; SharedProcessActive shared_process_active = 17;
} }
} }
message WorkingInitMessage { message WorkingInit {
string home_directory = 1; string home_directory = 1;
string tmp_directory = 2; string tmp_directory = 2;
string data_directory = 3; string data_directory = 3;

62
packages/protocol/src/proto/client_pb.d.ts vendored
View File

@ -8,8 +8,8 @@ import * as vscode_pb from "./vscode_pb";
export class ClientMessage extends jspb.Message { export class ClientMessage extends jspb.Message {
hasMethod(): boolean; hasMethod(): boolean;
clearMethod(): void; clearMethod(): void;
getMethod(): node_pb.MethodMessage | undefined; getMethod(): node_pb.Method | undefined;
setMethod(value?: node_pb.MethodMessage): void; setMethod(value?: node_pb.Method): void;
hasPing(): boolean; hasPing(): boolean;
clearPing(): void; clearPing(): void;
@ -29,7 +29,7 @@ export class ClientMessage extends jspb.Message {
export namespace ClientMessage { export namespace ClientMessage {
export type AsObject = { export type AsObject = {
method?: node_pb.MethodMessage.AsObject, method?: node_pb.Method.AsObject,
ping?: node_pb.Ping.AsObject, ping?: node_pb.Ping.AsObject,
} }
@ -43,23 +43,23 @@ export namespace ClientMessage {
export class ServerMessage extends jspb.Message { export class ServerMessage extends jspb.Message {
hasFail(): boolean; hasFail(): boolean;
clearFail(): void; clearFail(): void;
getFail(): node_pb.FailMessage | undefined; getFail(): node_pb.Method.Fail | undefined;
setFail(value?: node_pb.FailMessage): void; setFail(value?: node_pb.Method.Fail): void;
hasSuccess(): boolean; hasSuccess(): boolean;
clearSuccess(): void; clearSuccess(): void;
getSuccess(): node_pb.SuccessMessage | undefined; getSuccess(): node_pb.Method.Success | undefined;
setSuccess(value?: node_pb.SuccessMessage): void; setSuccess(value?: node_pb.Method.Success): void;
hasEvent(): boolean; hasEvent(): boolean;
clearEvent(): void; clearEvent(): void;
getEvent(): node_pb.EventMessage | undefined; getEvent(): node_pb.Event | undefined;
setEvent(value?: node_pb.EventMessage): void; setEvent(value?: node_pb.Event): void;
hasCallback(): boolean; hasCallback(): boolean;
clearCallback(): void; clearCallback(): void;
getCallback(): node_pb.CallbackMessage | undefined; getCallback(): node_pb.Callback | undefined;
setCallback(value?: node_pb.CallbackMessage): void; setCallback(value?: node_pb.Callback): void;
hasPong(): boolean; hasPong(): boolean;
clearPong(): void; clearPong(): void;
@ -68,13 +68,13 @@ export class ServerMessage extends jspb.Message {
hasInit(): boolean; hasInit(): boolean;
clearInit(): void; clearInit(): void;
getInit(): WorkingInitMessage | undefined; getInit(): WorkingInit | undefined;
setInit(value?: WorkingInitMessage): void; setInit(value?: WorkingInit): void;
hasSharedProcessActive(): boolean; hasSharedProcessActive(): boolean;
clearSharedProcessActive(): void; clearSharedProcessActive(): void;
getSharedProcessActive(): vscode_pb.SharedProcessActiveMessage | undefined; getSharedProcessActive(): vscode_pb.SharedProcessActive | undefined;
setSharedProcessActive(value?: vscode_pb.SharedProcessActiveMessage): void; setSharedProcessActive(value?: vscode_pb.SharedProcessActive): void;
getMsgCase(): ServerMessage.MsgCase; getMsgCase(): ServerMessage.MsgCase;
serializeBinary(): Uint8Array; serializeBinary(): Uint8Array;
@ -89,13 +89,13 @@ export class ServerMessage extends jspb.Message {
export namespace ServerMessage { export namespace ServerMessage {
export type AsObject = { export type AsObject = {
fail?: node_pb.FailMessage.AsObject, fail?: node_pb.Method.Fail.AsObject,
success?: node_pb.SuccessMessage.AsObject, success?: node_pb.Method.Success.AsObject,
event?: node_pb.EventMessage.AsObject, event?: node_pb.Event.AsObject,
callback?: node_pb.CallbackMessage.AsObject, callback?: node_pb.Callback.AsObject,
pong?: node_pb.Pong.AsObject, pong?: node_pb.Pong.AsObject,
init?: WorkingInitMessage.AsObject, init?: WorkingInit.AsObject,
sharedProcessActive?: vscode_pb.SharedProcessActiveMessage.AsObject, sharedProcessActive?: vscode_pb.SharedProcessActive.AsObject,
} }
export enum MsgCase { export enum MsgCase {
@ -110,7 +110,7 @@ export namespace ServerMessage {
} }
} }
export class WorkingInitMessage extends jspb.Message { export class WorkingInit extends jspb.Message {
getHomeDirectory(): string; getHomeDirectory(): string;
setHomeDirectory(value: string): void; setHomeDirectory(value: string): void;
@ -123,8 +123,8 @@ export class WorkingInitMessage extends jspb.Message {
getWorkingDirectory(): string; getWorkingDirectory(): string;
setWorkingDirectory(value: string): void; setWorkingDirectory(value: string): void;
getOperatingSystem(): WorkingInitMessage.OperatingSystem; getOperatingSystem(): WorkingInit.OperatingSystem;
setOperatingSystem(value: WorkingInitMessage.OperatingSystem): void; setOperatingSystem(value: WorkingInit.OperatingSystem): void;
getShell(): string; getShell(): string;
setShell(value: string): void; setShell(value: string): void;
@ -133,22 +133,22 @@ export class WorkingInitMessage extends jspb.Message {
setBuiltinExtensionsDir(value: string): void; setBuiltinExtensionsDir(value: string): void;
serializeBinary(): Uint8Array; serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): WorkingInitMessage.AsObject; toObject(includeInstance?: boolean): WorkingInit.AsObject;
static toObject(includeInstance: boolean, msg: WorkingInitMessage): WorkingInitMessage.AsObject; static toObject(includeInstance: boolean, msg: WorkingInit): WorkingInit.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>}; static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>}; static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: WorkingInitMessage, writer: jspb.BinaryWriter): void; static serializeBinaryToWriter(message: WorkingInit, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): WorkingInitMessage; static deserializeBinary(bytes: Uint8Array): WorkingInit;
static deserializeBinaryFromReader(message: WorkingInitMessage, reader: jspb.BinaryReader): WorkingInitMessage; static deserializeBinaryFromReader(message: WorkingInit, reader: jspb.BinaryReader): WorkingInit;
} }
export namespace WorkingInitMessage { export namespace WorkingInit {
export type AsObject = { export type AsObject = {
homeDirectory: string, homeDirectory: string,
tmpDirectory: string, tmpDirectory: string,
dataDirectory: string, dataDirectory: string,
workingDirectory: string, workingDirectory: string,
operatingSystem: WorkingInitMessage.OperatingSystem, operatingSystem: WorkingInit.OperatingSystem,
shell: string, shell: string,
builtinExtensionsDir: string, builtinExtensionsDir: string,
} }

333
packages/protocol/src/proto/client_pb.js
View File

@ -12,12 +12,13 @@ var goog = jspb;
var global = Function('return this')(); var global = Function('return this')();
var node_pb = require('./node_pb.js'); var node_pb = require('./node_pb.js');
goog.object.extend(proto, node_pb);
var vscode_pb = require('./vscode_pb.js'); var vscode_pb = require('./vscode_pb.js');
goog.object.extend(proto, vscode_pb);
goog.exportSymbol('proto.ClientMessage', null, global); goog.exportSymbol('proto.ClientMessage', null, global);
goog.exportSymbol('proto.ServerMessage', null, global); goog.exportSymbol('proto.ServerMessage', null, global);
goog.exportSymbol('proto.WorkingInitMessage', null, global); goog.exportSymbol('proto.WorkingInit', null, global);
goog.exportSymbol('proto.WorkingInitMessage.OperatingSystem', null, global); goog.exportSymbol('proto.WorkingInit.OperatingSystem', null, global);
/** /**
* Generated by JsPbCodeGenerator. * Generated by JsPbCodeGenerator.
* @param {Array=} opt_data Optional initial data array, typically from a * @param {Array=} opt_data Optional initial data array, typically from a
@ -33,8 +34,55 @@ proto.ClientMessage = function(opt_data) {
}; };
goog.inherits(proto.ClientMessage, jspb.Message); goog.inherits(proto.ClientMessage, jspb.Message);
if (goog.DEBUG && !COMPILED) { if (goog.DEBUG && !COMPILED) {
/**
* @public
* @override
*/
proto.ClientMessage.displayName = 'proto.ClientMessage'; proto.ClientMessage.displayName = 'proto.ClientMessage';
} }
/**
* 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.ServerMessage = function(opt_data) {
jspb.Message.initialize(this, opt_data, 0, -1, null, proto.ServerMessage.oneofGroups_);
};
goog.inherits(proto.ServerMessage, jspb.Message);
if (goog.DEBUG && !COMPILED) {
/**
* @public
* @override
*/
proto.ServerMessage.displayName = 'proto.ServerMessage';
}
/**
* 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.WorkingInit = function(opt_data) {
jspb.Message.initialize(this, opt_data, 0, -1, null, null);
};
goog.inherits(proto.WorkingInit, jspb.Message);
if (goog.DEBUG && !COMPILED) {
/**
* @public
* @override
*/
proto.WorkingInit.displayName = 'proto.WorkingInit';
}
/** /**
* Oneof group definitions for this message. Each group defines the field * Oneof group definitions for this message. Each group defines the field
* numbers belonging to that group. When of these fields' value is set, all * numbers belonging to that group. When of these fields' value is set, all
@ -89,8 +137,8 @@ proto.ClientMessage.prototype.toObject = function(opt_includeInstance) {
* @suppress {unusedLocalVariables} f is only used for nested messages * @suppress {unusedLocalVariables} f is only used for nested messages
*/ */
proto.ClientMessage.toObject = function(includeInstance, msg) { proto.ClientMessage.toObject = function(includeInstance, msg) {
var f, obj = { var obj = {
method: (f = msg.getMethod()) && node_pb.MethodMessage.toObject(includeInstance, f), method: (f = msg.getMethod()) && node_pb.Method.toObject(includeInstance, f),
ping: (f = msg.getPing()) && node_pb.Ping.toObject(includeInstance, f) ping: (f = msg.getPing()) && node_pb.Ping.toObject(includeInstance, f)
}; };
@ -129,8 +177,8 @@ proto.ClientMessage.deserializeBinaryFromReader = function(msg, reader) {
var field = reader.getFieldNumber(); var field = reader.getFieldNumber();
switch (field) { switch (field) {
case 20: case 20:
var value = new node_pb.MethodMessage; var value = new node_pb.Method;
reader.readMessage(value,node_pb.MethodMessage.deserializeBinaryFromReader); reader.readMessage(value,node_pb.Method.deserializeBinaryFromReader);
msg.setMethod(value); msg.setMethod(value);
break; break;
case 21: case 21:
@ -172,7 +220,7 @@ proto.ClientMessage.serializeBinaryToWriter = function(message, writer) {
writer.writeMessage( writer.writeMessage(
20, 20,
f, f,
node_pb.MethodMessage.serializeBinaryToWriter node_pb.Method.serializeBinaryToWriter
); );
} }
f = message.getPing(); f = message.getPing();
@ -187,21 +235,24 @@ proto.ClientMessage.serializeBinaryToWriter = function(message, writer) {
/** /**
* optional MethodMessage method = 20; * optional Method method = 20;
* @return {?proto.MethodMessage} * @return {?proto.Method}
*/ */
proto.ClientMessage.prototype.getMethod = function() { proto.ClientMessage.prototype.getMethod = function() {
return /** @type{?proto.MethodMessage} */ ( return /** @type{?proto.Method} */ (
jspb.Message.getWrapperField(this, node_pb.MethodMessage, 20)); jspb.Message.getWrapperField(this, node_pb.Method, 20));
}; };
/** @param {?proto.MethodMessage|undefined} value */ /** @param {?proto.Method|undefined} value */
proto.ClientMessage.prototype.setMethod = function(value) { proto.ClientMessage.prototype.setMethod = function(value) {
jspb.Message.setOneofWrapperField(this, 20, proto.ClientMessage.oneofGroups_[0], value); jspb.Message.setOneofWrapperField(this, 20, proto.ClientMessage.oneofGroups_[0], value);
}; };
/**
* Clears the message field making it undefined.
*/
proto.ClientMessage.prototype.clearMethod = function() { proto.ClientMessage.prototype.clearMethod = function() {
this.setMethod(undefined); this.setMethod(undefined);
}; };
@ -209,7 +260,7 @@ proto.ClientMessage.prototype.clearMethod = function() {
/** /**
* Returns whether this field is set. * Returns whether this field is set.
* @return {!boolean} * @return {boolean}
*/ */
proto.ClientMessage.prototype.hasMethod = function() { proto.ClientMessage.prototype.hasMethod = function() {
return jspb.Message.getField(this, 20) != null; return jspb.Message.getField(this, 20) != null;
@ -232,6 +283,9 @@ proto.ClientMessage.prototype.setPing = function(value) {
}; };
/**
* Clears the message field making it undefined.
*/
proto.ClientMessage.prototype.clearPing = function() { proto.ClientMessage.prototype.clearPing = function() {
this.setPing(undefined); this.setPing(undefined);
}; };
@ -239,7 +293,7 @@ proto.ClientMessage.prototype.clearPing = function() {
/** /**
* Returns whether this field is set. * Returns whether this field is set.
* @return {!boolean} * @return {boolean}
*/ */
proto.ClientMessage.prototype.hasPing = function() { proto.ClientMessage.prototype.hasPing = function() {
return jspb.Message.getField(this, 21) != null; return jspb.Message.getField(this, 21) != null;
@ -247,23 +301,6 @@ proto.ClientMessage.prototype.hasPing = function() {
/**
* 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.ServerMessage = function(opt_data) {
jspb.Message.initialize(this, opt_data, 0, -1, null, proto.ServerMessage.oneofGroups_);
};
goog.inherits(proto.ServerMessage, jspb.Message);
if (goog.DEBUG && !COMPILED) {
proto.ServerMessage.displayName = 'proto.ServerMessage';
}
/** /**
* Oneof group definitions for this message. Each group defines the field * Oneof group definitions for this message. Each group defines the field
* numbers belonging to that group. When of these fields' value is set, all * numbers belonging to that group. When of these fields' value is set, all
@ -323,14 +360,14 @@ proto.ServerMessage.prototype.toObject = function(opt_includeInstance) {
* @suppress {unusedLocalVariables} f is only used for nested messages * @suppress {unusedLocalVariables} f is only used for nested messages
*/ */
proto.ServerMessage.toObject = function(includeInstance, msg) { proto.ServerMessage.toObject = function(includeInstance, msg) {
var f, obj = { var obj = {
fail: (f = msg.getFail()) && node_pb.FailMessage.toObject(includeInstance, f), fail: (f = msg.getFail()) && node_pb.Method.Fail.toObject(includeInstance, f),
success: (f = msg.getSuccess()) && node_pb.SuccessMessage.toObject(includeInstance, f), success: (f = msg.getSuccess()) && node_pb.Method.Success.toObject(includeInstance, f),
event: (f = msg.getEvent()) && node_pb.EventMessage.toObject(includeInstance, f), event: (f = msg.getEvent()) && node_pb.Event.toObject(includeInstance, f),
callback: (f = msg.getCallback()) && node_pb.CallbackMessage.toObject(includeInstance, f), callback: (f = msg.getCallback()) && node_pb.Callback.toObject(includeInstance, f),
pong: (f = msg.getPong()) && node_pb.Pong.toObject(includeInstance, f), pong: (f = msg.getPong()) && node_pb.Pong.toObject(includeInstance, f),
init: (f = msg.getInit()) && proto.WorkingInitMessage.toObject(includeInstance, f), init: (f = msg.getInit()) && proto.WorkingInit.toObject(includeInstance, f),
sharedProcessActive: (f = msg.getSharedProcessActive()) && vscode_pb.SharedProcessActiveMessage.toObject(includeInstance, f) sharedProcessActive: (f = msg.getSharedProcessActive()) && vscode_pb.SharedProcessActive.toObject(includeInstance, f)
}; };
if (includeInstance) { if (includeInstance) {
@ -368,23 +405,23 @@ proto.ServerMessage.deserializeBinaryFromReader = function(msg, reader) {
var field = reader.getFieldNumber(); var field = reader.getFieldNumber();
switch (field) { switch (field) {
case 13: case 13:
var value = new node_pb.FailMessage; var value = new node_pb.Method.Fail;
reader.readMessage(value,node_pb.FailMessage.deserializeBinaryFromReader); reader.readMessage(value,node_pb.Method.Fail.deserializeBinaryFromReader);
msg.setFail(value); msg.setFail(value);
break; break;
case 14: case 14:
var value = new node_pb.SuccessMessage; var value = new node_pb.Method.Success;
reader.readMessage(value,node_pb.SuccessMessage.deserializeBinaryFromReader); reader.readMessage(value,node_pb.Method.Success.deserializeBinaryFromReader);
msg.setSuccess(value); msg.setSuccess(value);
break; break;
case 19: case 19:
var value = new node_pb.EventMessage; var value = new node_pb.Event;
reader.readMessage(value,node_pb.EventMessage.deserializeBinaryFromReader); reader.readMessage(value,node_pb.Event.deserializeBinaryFromReader);
msg.setEvent(value); msg.setEvent(value);
break; break;
case 22: case 22:
var value = new node_pb.CallbackMessage; var value = new node_pb.Callback;
reader.readMessage(value,node_pb.CallbackMessage.deserializeBinaryFromReader); reader.readMessage(value,node_pb.Callback.deserializeBinaryFromReader);
msg.setCallback(value); msg.setCallback(value);
break; break;
case 18: case 18:
@ -393,13 +430,13 @@ proto.ServerMessage.deserializeBinaryFromReader = function(msg, reader) {
msg.setPong(value); msg.setPong(value);
break; break;
case 16: case 16:
var value = new proto.WorkingInitMessage; var value = new proto.WorkingInit;
reader.readMessage(value,proto.WorkingInitMessage.deserializeBinaryFromReader); reader.readMessage(value,proto.WorkingInit.deserializeBinaryFromReader);
msg.setInit(value); msg.setInit(value);
break; break;
case 17: case 17:
var value = new vscode_pb.SharedProcessActiveMessage; var value = new vscode_pb.SharedProcessActive;
reader.readMessage(value,vscode_pb.SharedProcessActiveMessage.deserializeBinaryFromReader); reader.readMessage(value,vscode_pb.SharedProcessActive.deserializeBinaryFromReader);
msg.setSharedProcessActive(value); msg.setSharedProcessActive(value);
break; break;
default: default:
@ -436,7 +473,7 @@ proto.ServerMessage.serializeBinaryToWriter = function(message, writer) {
writer.writeMessage( writer.writeMessage(
13, 13,
f, f,
node_pb.FailMessage.serializeBinaryToWriter node_pb.Method.Fail.serializeBinaryToWriter
); );
} }
f = message.getSuccess(); f = message.getSuccess();
@ -444,7 +481,7 @@ proto.ServerMessage.serializeBinaryToWriter = function(message, writer) {
writer.writeMessage( writer.writeMessage(
14, 14,
f, f,
node_pb.SuccessMessage.serializeBinaryToWriter node_pb.Method.Success.serializeBinaryToWriter
); );
} }
f = message.getEvent(); f = message.getEvent();
@ -452,7 +489,7 @@ proto.ServerMessage.serializeBinaryToWriter = function(message, writer) {
writer.writeMessage( writer.writeMessage(
19, 19,
f, f,
node_pb.EventMessage.serializeBinaryToWriter node_pb.Event.serializeBinaryToWriter
); );
} }
f = message.getCallback(); f = message.getCallback();
@ -460,7 +497,7 @@ proto.ServerMessage.serializeBinaryToWriter = function(message, writer) {
writer.writeMessage( writer.writeMessage(
22, 22,
f, f,
node_pb.CallbackMessage.serializeBinaryToWriter node_pb.Callback.serializeBinaryToWriter
); );
} }
f = message.getPong(); f = message.getPong();
@ -476,7 +513,7 @@ proto.ServerMessage.serializeBinaryToWriter = function(message, writer) {
writer.writeMessage( writer.writeMessage(
16, 16,
f, f,
proto.WorkingInitMessage.serializeBinaryToWriter proto.WorkingInit.serializeBinaryToWriter
); );
} }
f = message.getSharedProcessActive(); f = message.getSharedProcessActive();
@ -484,28 +521,31 @@ proto.ServerMessage.serializeBinaryToWriter = function(message, writer) {
writer.writeMessage( writer.writeMessage(
17, 17,
f, f,
vscode_pb.SharedProcessActiveMessage.serializeBinaryToWriter vscode_pb.SharedProcessActive.serializeBinaryToWriter
); );
} }
}; };
/** /**
* optional FailMessage fail = 13; * optional Method.Fail fail = 13;
* @return {?proto.FailMessage} * @return {?proto.Method.Fail}
*/ */
proto.ServerMessage.prototype.getFail = function() { proto.ServerMessage.prototype.getFail = function() {
return /** @type{?proto.FailMessage} */ ( return /** @type{?proto.Method.Fail} */ (
jspb.Message.getWrapperField(this, node_pb.FailMessage, 13)); jspb.Message.getWrapperField(this, node_pb.Method.Fail, 13));
}; };
/** @param {?proto.FailMessage|undefined} value */ /** @param {?proto.Method.Fail|undefined} value */
proto.ServerMessage.prototype.setFail = function(value) { proto.ServerMessage.prototype.setFail = function(value) {
jspb.Message.setOneofWrapperField(this, 13, proto.ServerMessage.oneofGroups_[0], value); jspb.Message.setOneofWrapperField(this, 13, proto.ServerMessage.oneofGroups_[0], value);
}; };
/**
* Clears the message field making it undefined.
*/
proto.ServerMessage.prototype.clearFail = function() { proto.ServerMessage.prototype.clearFail = function() {
this.setFail(undefined); this.setFail(undefined);
}; };
@ -513,7 +553,7 @@ proto.ServerMessage.prototype.clearFail = function() {
/** /**
* Returns whether this field is set. * Returns whether this field is set.
* @return {!boolean} * @return {boolean}
*/ */
proto.ServerMessage.prototype.hasFail = function() { proto.ServerMessage.prototype.hasFail = function() {
return jspb.Message.getField(this, 13) != null; return jspb.Message.getField(this, 13) != null;
@ -521,21 +561,24 @@ proto.ServerMessage.prototype.hasFail = function() {
/** /**
* optional SuccessMessage success = 14; * optional Method.Success success = 14;
* @return {?proto.SuccessMessage} * @return {?proto.Method.Success}
*/ */
proto.ServerMessage.prototype.getSuccess = function() { proto.ServerMessage.prototype.getSuccess = function() {
return /** @type{?proto.SuccessMessage} */ ( return /** @type{?proto.Method.Success} */ (
jspb.Message.getWrapperField(this, node_pb.SuccessMessage, 14)); jspb.Message.getWrapperField(this, node_pb.Method.Success, 14));
}; };
/** @param {?proto.SuccessMessage|undefined} value */ /** @param {?proto.Method.Success|undefined} value */
proto.ServerMessage.prototype.setSuccess = function(value) { proto.ServerMessage.prototype.setSuccess = function(value) {
jspb.Message.setOneofWrapperField(this, 14, proto.ServerMessage.oneofGroups_[0], value); jspb.Message.setOneofWrapperField(this, 14, proto.ServerMessage.oneofGroups_[0], value);
}; };
/**
* Clears the message field making it undefined.
*/
proto.ServerMessage.prototype.clearSuccess = function() { proto.ServerMessage.prototype.clearSuccess = function() {
this.setSuccess(undefined); this.setSuccess(undefined);
}; };
@ -543,7 +586,7 @@ proto.ServerMessage.prototype.clearSuccess = function() {
/** /**
* Returns whether this field is set. * Returns whether this field is set.
* @return {!boolean} * @return {boolean}
*/ */
proto.ServerMessage.prototype.hasSuccess = function() { proto.ServerMessage.prototype.hasSuccess = function() {
return jspb.Message.getField(this, 14) != null; return jspb.Message.getField(this, 14) != null;
@ -551,21 +594,24 @@ proto.ServerMessage.prototype.hasSuccess = function() {
/** /**
* optional EventMessage event = 19; * optional Event event = 19;
* @return {?proto.EventMessage} * @return {?proto.Event}
*/ */
proto.ServerMessage.prototype.getEvent = function() { proto.ServerMessage.prototype.getEvent = function() {
return /** @type{?proto.EventMessage} */ ( return /** @type{?proto.Event} */ (
jspb.Message.getWrapperField(this, node_pb.EventMessage, 19)); jspb.Message.getWrapperField(this, node_pb.Event, 19));
}; };
/** @param {?proto.EventMessage|undefined} value */ /** @param {?proto.Event|undefined} value */
proto.ServerMessage.prototype.setEvent = function(value) { proto.ServerMessage.prototype.setEvent = function(value) {
jspb.Message.setOneofWrapperField(this, 19, proto.ServerMessage.oneofGroups_[0], value); jspb.Message.setOneofWrapperField(this, 19, proto.ServerMessage.oneofGroups_[0], value);
}; };
/**
* Clears the message field making it undefined.
*/
proto.ServerMessage.prototype.clearEvent = function() { proto.ServerMessage.prototype.clearEvent = function() {
this.setEvent(undefined); this.setEvent(undefined);
}; };
@ -573,7 +619,7 @@ proto.ServerMessage.prototype.clearEvent = function() {
/** /**
* Returns whether this field is set. * Returns whether this field is set.
* @return {!boolean} * @return {boolean}
*/ */
proto.ServerMessage.prototype.hasEvent = function() { proto.ServerMessage.prototype.hasEvent = function() {
return jspb.Message.getField(this, 19) != null; return jspb.Message.getField(this, 19) != null;
@ -581,21 +627,24 @@ proto.ServerMessage.prototype.hasEvent = function() {
/** /**
* optional CallbackMessage callback = 22; * optional Callback callback = 22;
* @return {?proto.CallbackMessage} * @return {?proto.Callback}
*/ */
proto.ServerMessage.prototype.getCallback = function() { proto.ServerMessage.prototype.getCallback = function() {
return /** @type{?proto.CallbackMessage} */ ( return /** @type{?proto.Callback} */ (
jspb.Message.getWrapperField(this, node_pb.CallbackMessage, 22)); jspb.Message.getWrapperField(this, node_pb.Callback, 22));
}; };
/** @param {?proto.CallbackMessage|undefined} value */ /** @param {?proto.Callback|undefined} value */
proto.ServerMessage.prototype.setCallback = function(value) { proto.ServerMessage.prototype.setCallback = function(value) {
jspb.Message.setOneofWrapperField(this, 22, proto.ServerMessage.oneofGroups_[0], value); jspb.Message.setOneofWrapperField(this, 22, proto.ServerMessage.oneofGroups_[0], value);
}; };
/**
* Clears the message field making it undefined.
*/
proto.ServerMessage.prototype.clearCallback = function() { proto.ServerMessage.prototype.clearCallback = function() {
this.setCallback(undefined); this.setCallback(undefined);
}; };
@ -603,7 +652,7 @@ proto.ServerMessage.prototype.clearCallback = function() {
/** /**
* Returns whether this field is set. * Returns whether this field is set.
* @return {!boolean} * @return {boolean}
*/ */
proto.ServerMessage.prototype.hasCallback = function() { proto.ServerMessage.prototype.hasCallback = function() {
return jspb.Message.getField(this, 22) != null; return jspb.Message.getField(this, 22) != null;
@ -626,6 +675,9 @@ proto.ServerMessage.prototype.setPong = function(value) {
}; };
/**
* Clears the message field making it undefined.
*/
proto.ServerMessage.prototype.clearPong = function() { proto.ServerMessage.prototype.clearPong = function() {
this.setPong(undefined); this.setPong(undefined);
}; };
@ -633,7 +685,7 @@ proto.ServerMessage.prototype.clearPong = function() {
/** /**
* Returns whether this field is set. * Returns whether this field is set.
* @return {!boolean} * @return {boolean}
*/ */
proto.ServerMessage.prototype.hasPong = function() { proto.ServerMessage.prototype.hasPong = function() {
return jspb.Message.getField(this, 18) != null; return jspb.Message.getField(this, 18) != null;
@ -641,21 +693,24 @@ proto.ServerMessage.prototype.hasPong = function() {
/** /**
* optional WorkingInitMessage init = 16; * optional WorkingInit init = 16;
* @return {?proto.WorkingInitMessage} * @return {?proto.WorkingInit}
*/ */
proto.ServerMessage.prototype.getInit = function() { proto.ServerMessage.prototype.getInit = function() {
return /** @type{?proto.WorkingInitMessage} */ ( return /** @type{?proto.WorkingInit} */ (
jspb.Message.getWrapperField(this, proto.WorkingInitMessage, 16)); jspb.Message.getWrapperField(this, proto.WorkingInit, 16));
}; };
/** @param {?proto.WorkingInitMessage|undefined} value */ /** @param {?proto.WorkingInit|undefined} value */
proto.ServerMessage.prototype.setInit = function(value) { proto.ServerMessage.prototype.setInit = function(value) {
jspb.Message.setOneofWrapperField(this, 16, proto.ServerMessage.oneofGroups_[0], value); jspb.Message.setOneofWrapperField(this, 16, proto.ServerMessage.oneofGroups_[0], value);
}; };
/**
* Clears the message field making it undefined.
*/
proto.ServerMessage.prototype.clearInit = function() { proto.ServerMessage.prototype.clearInit = function() {
this.setInit(undefined); this.setInit(undefined);
}; };
@ -663,7 +718,7 @@ proto.ServerMessage.prototype.clearInit = function() {
/** /**
* Returns whether this field is set. * Returns whether this field is set.
* @return {!boolean} * @return {boolean}
*/ */
proto.ServerMessage.prototype.hasInit = function() { proto.ServerMessage.prototype.hasInit = function() {
return jspb.Message.getField(this, 16) != null; return jspb.Message.getField(this, 16) != null;
@ -671,21 +726,24 @@ proto.ServerMessage.prototype.hasInit = function() {
/** /**
* optional SharedProcessActiveMessage shared_process_active = 17; * optional SharedProcessActive shared_process_active = 17;
* @return {?proto.SharedProcessActiveMessage} * @return {?proto.SharedProcessActive}
*/ */
proto.ServerMessage.prototype.getSharedProcessActive = function() { proto.ServerMessage.prototype.getSharedProcessActive = function() {
return /** @type{?proto.SharedProcessActiveMessage} */ ( return /** @type{?proto.SharedProcessActive} */ (
jspb.Message.getWrapperField(this, vscode_pb.SharedProcessActiveMessage, 17)); jspb.Message.getWrapperField(this, vscode_pb.SharedProcessActive, 17));
}; };
/** @param {?proto.SharedProcessActiveMessage|undefined} value */ /** @param {?proto.SharedProcessActive|undefined} value */
proto.ServerMessage.prototype.setSharedProcessActive = function(value) { proto.ServerMessage.prototype.setSharedProcessActive = function(value) {
jspb.Message.setOneofWrapperField(this, 17, proto.ServerMessage.oneofGroups_[0], value); jspb.Message.setOneofWrapperField(this, 17, proto.ServerMessage.oneofGroups_[0], value);
}; };
/**
* Clears the message field making it undefined.
*/
proto.ServerMessage.prototype.clearSharedProcessActive = function() { proto.ServerMessage.prototype.clearSharedProcessActive = function() {
this.setSharedProcessActive(undefined); this.setSharedProcessActive(undefined);
}; };
@ -693,7 +751,7 @@ proto.ServerMessage.prototype.clearSharedProcessActive = function() {
/** /**
* Returns whether this field is set. * Returns whether this field is set.
* @return {!boolean} * @return {boolean}
*/ */
proto.ServerMessage.prototype.hasSharedProcessActive = function() { proto.ServerMessage.prototype.hasSharedProcessActive = function() {
return jspb.Message.getField(this, 17) != null; return jspb.Message.getField(this, 17) != null;
@ -701,23 +759,6 @@ proto.ServerMessage.prototype.hasSharedProcessActive = function() {
/**
* 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.WorkingInitMessage = function(opt_data) {
jspb.Message.initialize(this, opt_data, 0, -1, null, null);
};
goog.inherits(proto.WorkingInitMessage, jspb.Message);
if (goog.DEBUG && !COMPILED) {
proto.WorkingInitMessage.displayName = 'proto.WorkingInitMessage';
}
if (jspb.Message.GENERATE_TO_OBJECT) { if (jspb.Message.GENERATE_TO_OBJECT) {
@ -731,8 +772,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) {
* for transitional soy proto support: http://goto/soy-param-migration * for transitional soy proto support: http://goto/soy-param-migration
* @return {!Object} * @return {!Object}
*/ */
proto.WorkingInitMessage.prototype.toObject = function(opt_includeInstance) { proto.WorkingInit.prototype.toObject = function(opt_includeInstance) {
return proto.WorkingInitMessage.toObject(opt_includeInstance, this); return proto.WorkingInit.toObject(opt_includeInstance, this);
}; };
@ -741,12 +782,12 @@ proto.WorkingInitMessage.prototype.toObject = function(opt_includeInstance) {
* @param {boolean|undefined} includeInstance Whether to include the JSPB * @param {boolean|undefined} includeInstance Whether to include the JSPB
* instance for transitional soy proto support: * instance for transitional soy proto support:
* http://goto/soy-param-migration * http://goto/soy-param-migration
* @param {!proto.WorkingInitMessage} msg The msg instance to transform. * @param {!proto.WorkingInit} msg The msg instance to transform.
* @return {!Object} * @return {!Object}
* @suppress {unusedLocalVariables} f is only used for nested messages * @suppress {unusedLocalVariables} f is only used for nested messages
*/ */
proto.WorkingInitMessage.toObject = function(includeInstance, msg) { proto.WorkingInit.toObject = function(includeInstance, msg) {
var f, obj = { var obj = {
homeDirectory: jspb.Message.getFieldWithDefault(msg, 1, ""), homeDirectory: jspb.Message.getFieldWithDefault(msg, 1, ""),
tmpDirectory: jspb.Message.getFieldWithDefault(msg, 2, ""), tmpDirectory: jspb.Message.getFieldWithDefault(msg, 2, ""),
dataDirectory: jspb.Message.getFieldWithDefault(msg, 3, ""), dataDirectory: jspb.Message.getFieldWithDefault(msg, 3, ""),
@ -767,23 +808,23 @@ proto.WorkingInitMessage.toObject = function(includeInstance, msg) {
/** /**
* Deserializes binary data (in protobuf wire format). * Deserializes binary data (in protobuf wire format).
* @param {jspb.ByteSource} bytes The bytes to deserialize. * @param {jspb.ByteSource} bytes The bytes to deserialize.
* @return {!proto.WorkingInitMessage} * @return {!proto.WorkingInit}
*/ */
proto.WorkingInitMessage.deserializeBinary = function(bytes) { proto.WorkingInit.deserializeBinary = function(bytes) {
var reader = new jspb.BinaryReader(bytes); var reader = new jspb.BinaryReader(bytes);
var msg = new proto.WorkingInitMessage; var msg = new proto.WorkingInit;
return proto.WorkingInitMessage.deserializeBinaryFromReader(msg, reader); return proto.WorkingInit.deserializeBinaryFromReader(msg, reader);
}; };
/** /**
* Deserializes binary data (in protobuf wire format) from the * Deserializes binary data (in protobuf wire format) from the
* given reader into the given message object. * given reader into the given message object.
* @param {!proto.WorkingInitMessage} msg The message object to deserialize into. * @param {!proto.WorkingInit} msg The message object to deserialize into.
* @param {!jspb.BinaryReader} reader The BinaryReader to use. * @param {!jspb.BinaryReader} reader The BinaryReader to use.
* @return {!proto.WorkingInitMessage} * @return {!proto.WorkingInit}
*/ */
proto.WorkingInitMessage.deserializeBinaryFromReader = function(msg, reader) { proto.WorkingInit.deserializeBinaryFromReader = function(msg, reader) {
while (reader.nextField()) { while (reader.nextField()) {
if (reader.isEndGroup()) { if (reader.isEndGroup()) {
break; break;
@ -807,7 +848,7 @@ proto.WorkingInitMessage.deserializeBinaryFromReader = function(msg, reader) {
msg.setWorkingDirectory(value); msg.setWorkingDirectory(value);
break; break;
case 5: case 5:
var value = /** @type {!proto.WorkingInitMessage.OperatingSystem} */ (reader.readEnum()); var value = /** @type {!proto.WorkingInit.OperatingSystem} */ (reader.readEnum());
msg.setOperatingSystem(value); msg.setOperatingSystem(value);
break; break;
case 6: case 6:
@ -831,9 +872,9 @@ proto.WorkingInitMessage.deserializeBinaryFromReader = function(msg, reader) {
* Serializes the message to binary data (in protobuf wire format). * Serializes the message to binary data (in protobuf wire format).
* @return {!Uint8Array} * @return {!Uint8Array}
*/ */
proto.WorkingInitMessage.prototype.serializeBinary = function() { proto.WorkingInit.prototype.serializeBinary = function() {
var writer = new jspb.BinaryWriter(); var writer = new jspb.BinaryWriter();
proto.WorkingInitMessage.serializeBinaryToWriter(this, writer); proto.WorkingInit.serializeBinaryToWriter(this, writer);
return writer.getResultBuffer(); return writer.getResultBuffer();
}; };
@ -841,11 +882,11 @@ proto.WorkingInitMessage.prototype.serializeBinary = function() {
/** /**
* Serializes the given message to binary data (in protobuf wire * Serializes the given message to binary data (in protobuf wire
* format), writing to the given BinaryWriter. * format), writing to the given BinaryWriter.
* @param {!proto.WorkingInitMessage} message * @param {!proto.WorkingInit} message
* @param {!jspb.BinaryWriter} writer * @param {!jspb.BinaryWriter} writer
* @suppress {unusedLocalVariables} f is only used for nested messages * @suppress {unusedLocalVariables} f is only used for nested messages
*/ */
proto.WorkingInitMessage.serializeBinaryToWriter = function(message, writer) { proto.WorkingInit.serializeBinaryToWriter = function(message, writer) {
var f = undefined; var f = undefined;
f = message.getHomeDirectory(); f = message.getHomeDirectory();
if (f.length > 0) { if (f.length > 0) {
@ -902,7 +943,7 @@ proto.WorkingInitMessage.serializeBinaryToWriter = function(message, writer) {
/** /**
* @enum {number} * @enum {number}
*/ */
proto.WorkingInitMessage.OperatingSystem = { proto.WorkingInit.OperatingSystem = {
WINDOWS: 0, WINDOWS: 0,
LINUX: 1, LINUX: 1,
MAC: 2 MAC: 2
@ -912,13 +953,13 @@ proto.WorkingInitMessage.OperatingSystem = {
* optional string home_directory = 1; * optional string home_directory = 1;
* @return {string} * @return {string}
*/ */
proto.WorkingInitMessage.prototype.getHomeDirectory = function() { proto.WorkingInit.prototype.getHomeDirectory = function() {
return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, ""));
}; };
/** @param {string} value */ /** @param {string} value */
proto.WorkingInitMessage.prototype.setHomeDirectory = function(value) { proto.WorkingInit.prototype.setHomeDirectory = function(value) {
jspb.Message.setProto3StringField(this, 1, value); jspb.Message.setProto3StringField(this, 1, value);
}; };
@ -927,13 +968,13 @@ proto.WorkingInitMessage.prototype.setHomeDirectory = function(value) {
* optional string tmp_directory = 2; * optional string tmp_directory = 2;
* @return {string} * @return {string}
*/ */
proto.WorkingInitMessage.prototype.getTmpDirectory = function() { proto.WorkingInit.prototype.getTmpDirectory = function() {
return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, ""));
}; };
/** @param {string} value */ /** @param {string} value */
proto.WorkingInitMessage.prototype.setTmpDirectory = function(value) { proto.WorkingInit.prototype.setTmpDirectory = function(value) {
jspb.Message.setProto3StringField(this, 2, value); jspb.Message.setProto3StringField(this, 2, value);
}; };
@ -942,13 +983,13 @@ proto.WorkingInitMessage.prototype.setTmpDirectory = function(value) {
* optional string data_directory = 3; * optional string data_directory = 3;
* @return {string} * @return {string}
*/ */
proto.WorkingInitMessage.prototype.getDataDirectory = function() { proto.WorkingInit.prototype.getDataDirectory = function() {
return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, "")); return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, ""));
}; };
/** @param {string} value */ /** @param {string} value */
proto.WorkingInitMessage.prototype.setDataDirectory = function(value) { proto.WorkingInit.prototype.setDataDirectory = function(value) {
jspb.Message.setProto3StringField(this, 3, value); jspb.Message.setProto3StringField(this, 3, value);
}; };
@ -957,28 +998,28 @@ proto.WorkingInitMessage.prototype.setDataDirectory = function(value) {
* optional string working_directory = 4; * optional string working_directory = 4;
* @return {string} * @return {string}
*/ */
proto.WorkingInitMessage.prototype.getWorkingDirectory = function() { proto.WorkingInit.prototype.getWorkingDirectory = function() {
return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 4, "")); return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 4, ""));
}; };
/** @param {string} value */ /** @param {string} value */
proto.WorkingInitMessage.prototype.setWorkingDirectory = function(value) { proto.WorkingInit.prototype.setWorkingDirectory = function(value) {
jspb.Message.setProto3StringField(this, 4, value); jspb.Message.setProto3StringField(this, 4, value);
}; };
/** /**
* optional OperatingSystem operating_system = 5; * optional OperatingSystem operating_system = 5;
* @return {!proto.WorkingInitMessage.OperatingSystem} * @return {!proto.WorkingInit.OperatingSystem}
*/ */
proto.WorkingInitMessage.prototype.getOperatingSystem = function() { proto.WorkingInit.prototype.getOperatingSystem = function() {
return /** @type {!proto.WorkingInitMessage.OperatingSystem} */ (jspb.Message.getFieldWithDefault(this, 5, 0)); return /** @type {!proto.WorkingInit.OperatingSystem} */ (jspb.Message.getFieldWithDefault(this, 5, 0));
}; };
/** @param {!proto.WorkingInitMessage.OperatingSystem} value */ /** @param {!proto.WorkingInit.OperatingSystem} value */
proto.WorkingInitMessage.prototype.setOperatingSystem = function(value) { proto.WorkingInit.prototype.setOperatingSystem = function(value) {
jspb.Message.setProto3EnumField(this, 5, value); jspb.Message.setProto3EnumField(this, 5, value);
}; };
@ -987,13 +1028,13 @@ proto.WorkingInitMessage.prototype.setOperatingSystem = function(value) {
* optional string shell = 6; * optional string shell = 6;
* @return {string} * @return {string}
*/ */
proto.WorkingInitMessage.prototype.getShell = function() { proto.WorkingInit.prototype.getShell = function() {
return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 6, "")); return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 6, ""));
}; };
/** @param {string} value */ /** @param {string} value */
proto.WorkingInitMessage.prototype.setShell = function(value) { proto.WorkingInit.prototype.setShell = function(value) {
jspb.Message.setProto3StringField(this, 6, value); jspb.Message.setProto3StringField(this, 6, value);
}; };
@ -1002,13 +1043,13 @@ proto.WorkingInitMessage.prototype.setShell = function(value) {
* optional string builtin_extensions_dir = 7; * optional string builtin_extensions_dir = 7;
* @return {string} * @return {string}
*/ */
proto.WorkingInitMessage.prototype.getBuiltinExtensionsDir = function() { proto.WorkingInit.prototype.getBuiltinExtensionsDir = function() {
return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 7, "")); return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 7, ""));
}; };
/** @param {string} value */ /** @param {string} value */
proto.WorkingInitMessage.prototype.setBuiltinExtensionsDir = function(value) { proto.WorkingInit.prototype.setBuiltinExtensionsDir = function(value) {
jspb.Message.setProto3StringField(this, 7, value); jspb.Message.setProto3StringField(this, 7, value);
}; };

150
packages/protocol/src/proto/node.proto
View File

@ -9,84 +9,128 @@ enum Module {
Trash = 5; Trash = 5;
} }
// A proxy identified by a unique name like "fs". message Argument {
message NamedProxyMessage { message ErrorValue {
uint64 id = 1; string message = 1;
Module module = 2; string stack = 2;
string method = 3; string code = 3;
repeated string args = 4; }
}
// A general proxy identified by an ID like WriteStream. message BufferValue {
message NumberedProxyMessage { bytes data = 1;
}
message ObjectValue {
map<string, Argument> data = 1;
}
message ArrayValue {
repeated Argument data = 1;
}
message ProxyValue {
uint64 id = 1; uint64 id = 1;
uint64 proxy_id = 2; }
string method = 3;
repeated string args = 4; message FunctionValue {
uint64 id = 1;
}
message NullValue {}
message UndefinedValue {}
oneof msg {
ErrorValue error = 1;
BufferValue buffer = 2;
ObjectValue object = 3;
ArrayValue array = 4;
ProxyValue proxy = 5;
FunctionValue function = 6;
NullValue null = 7;
UndefinedValue undefined = 8;
double number = 9;
string string = 10;
bool boolean = 11;
}
} }
// Call a remote method. // Call a remote method.
message MethodMessage { message Method {
// A proxy identified by a unique name like "fs".
message Named {
uint64 id = 1;
Module module = 2;
string method = 3;
repeated Argument args = 4;
}
// A general proxy identified by an ID like WriteStream.
message Numbered {
uint64 id = 1;
uint64 proxy_id = 2;
string method = 3;
repeated Argument args = 4;
}
// Remote method failed.
message Fail {
uint64 id = 1;
Argument response = 2;
}
// Remote method succeeded.
message Success {
uint64 id = 1;
Argument response = 2;
}
oneof msg { oneof msg {
NamedProxyMessage named_proxy = 1; Method.Named named_proxy = 1;
NumberedProxyMessage numbered_proxy = 2; Method.Numbered numbered_proxy = 2;
} }
} }
// Call a remote callback. message Callback {
message CallbackMessage { // A remote callback for uniquely named proxy.
oneof msg { message Named {
NamedCallbackMessage named_callback = 1;
NumberedCallbackMessage numbered_callback = 2;
}
}
// A remote callback for uniquely named proxy.
message NamedCallbackMessage {
Module module = 1; Module module = 1;
uint64 callback_id = 2; uint64 callback_id = 2;
repeated string args = 3; repeated Argument args = 3;
} }
// A remote callback for a numbered proxy. // A remote callback for a numbered proxy.
message NumberedCallbackMessage { message Numbered {
uint64 proxy_id = 1; uint64 proxy_id = 1;
uint64 callback_id = 2; uint64 callback_id = 2;
repeated string args = 3; repeated Argument args = 3;
} }
// Emit an event.
message EventMessage {
oneof msg { oneof msg {
NamedEventMessage named_event = 1; Callback.Named named_callback = 1;
NumberedEventMessage numbered_event = 2; Callback.Numbered numbered_callback = 2;
} }
} }
// Emit an event on a uniquely named proxy. message Event {
message NamedEventMessage { // Emit an event on a uniquely named proxy.
message Named {
Module module = 1; Module module = 1;
string event = 2; string event = 2;
repeated string args = 3; repeated Argument args = 3;
} }
// Emit an event on a numbered proxy. // Emit an event on a numbered proxy.
message NumberedEventMessage { message Numbered {
uint64 proxy_id = 1; uint64 proxy_id = 1;
string event = 2; string event = 2;
repeated string args = 3; repeated Argument args = 3;
} }
// Remote method failed. oneof msg {
message FailMessage { Event.Named named_event = 1;
uint64 id = 1; Event.Numbered numbered_event = 2;
string response = 2; }
}
// Remote method succeeded.
message SuccessMessage {
uint64 id = 1;
string response = 2;
} }
message Ping {} message Ping {}

747
packages/protocol/src/proto/node_pb.d.ts vendored
View File

@ -3,7 +3,296 @@
import * as jspb from "google-protobuf"; import * as jspb from "google-protobuf";
export class NamedProxyMessage extends jspb.Message { export class Argument extends jspb.Message {
hasError(): boolean;
clearError(): void;
getError(): Argument.ErrorValue | undefined;
setError(value?: Argument.ErrorValue): void;
hasBuffer(): boolean;
clearBuffer(): void;
getBuffer(): Argument.BufferValue | undefined;
setBuffer(value?: Argument.BufferValue): void;
hasObject(): boolean;
clearObject(): void;
getObject(): Argument.ObjectValue | undefined;
setObject(value?: Argument.ObjectValue): void;
hasArray(): boolean;
clearArray(): void;
getArray(): Argument.ArrayValue | undefined;
setArray(value?: Argument.ArrayValue): void;
hasProxy(): boolean;
clearProxy(): void;
getProxy(): Argument.ProxyValue | undefined;
setProxy(value?: Argument.ProxyValue): void;
hasFunction(): boolean;
clearFunction(): void;
getFunction(): Argument.FunctionValue | undefined;
setFunction(value?: Argument.FunctionValue): void;
hasNull(): boolean;
clearNull(): void;
getNull(): Argument.NullValue | undefined;
setNull(value?: Argument.NullValue): void;
hasUndefined(): boolean;
clearUndefined(): void;
getUndefined(): Argument.UndefinedValue | undefined;
setUndefined(value?: Argument.UndefinedValue): void;
hasNumber(): boolean;
clearNumber(): void;
getNumber(): number;
setNumber(value: number): void;
hasString(): boolean;
clearString(): void;
getString(): string;
setString(value: string): void;
hasBoolean(): boolean;
clearBoolean(): void;
getBoolean(): boolean;
setBoolean(value: boolean): void;
getMsgCase(): Argument.MsgCase;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): Argument.AsObject;
static toObject(includeInstance: boolean, msg: Argument): Argument.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: Argument, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): Argument;
static deserializeBinaryFromReader(message: Argument, reader: jspb.BinaryReader): Argument;
}
export namespace Argument {
export type AsObject = {
error?: Argument.ErrorValue.AsObject,
buffer?: Argument.BufferValue.AsObject,
object?: Argument.ObjectValue.AsObject,
array?: Argument.ArrayValue.AsObject,
proxy?: Argument.ProxyValue.AsObject,
pb_function?: Argument.FunctionValue.AsObject,
pb_null?: Argument.NullValue.AsObject,
undefined?: Argument.UndefinedValue.AsObject,
number: number,
string: string,
pb_boolean: boolean,
}
export class ErrorValue extends jspb.Message {
getMessage(): string;
setMessage(value: string): void;
getStack(): string;
setStack(value: string): void;
getCode(): string;
setCode(value: string): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): ErrorValue.AsObject;
static toObject(includeInstance: boolean, msg: ErrorValue): ErrorValue.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: ErrorValue, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): ErrorValue;
static deserializeBinaryFromReader(message: ErrorValue, reader: jspb.BinaryReader): ErrorValue;
}
export namespace ErrorValue {
export type AsObject = {
message: string,
stack: string,
code: string,
}
}
export class BufferValue extends jspb.Message {
getData(): Uint8Array | string;
getData_asU8(): Uint8Array;
getData_asB64(): string;
setData(value: Uint8Array | string): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): BufferValue.AsObject;
static toObject(includeInstance: boolean, msg: BufferValue): BufferValue.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: BufferValue, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): BufferValue;
static deserializeBinaryFromReader(message: BufferValue, reader: jspb.BinaryReader): BufferValue;
}
export namespace BufferValue {
export type AsObject = {
data: Uint8Array | string,
}
}
export class ObjectValue extends jspb.Message {
getDataMap(): jspb.Map<string, Argument>;
clearDataMap(): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): ObjectValue.AsObject;
static toObject(includeInstance: boolean, msg: ObjectValue): ObjectValue.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: ObjectValue, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): ObjectValue;
static deserializeBinaryFromReader(message: ObjectValue, reader: jspb.BinaryReader): ObjectValue;
}
export namespace ObjectValue {
export type AsObject = {
dataMap: Array<[string, Argument.AsObject]>,
}
}
export class ArrayValue extends jspb.Message {
clearDataList(): void;
getDataList(): Array<Argument>;
setDataList(value: Array<Argument>): void;
addData(value?: Argument, index?: number): Argument;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): ArrayValue.AsObject;
static toObject(includeInstance: boolean, msg: ArrayValue): ArrayValue.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: ArrayValue, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): ArrayValue;
static deserializeBinaryFromReader(message: ArrayValue, reader: jspb.BinaryReader): ArrayValue;
}
export namespace ArrayValue {
export type AsObject = {
dataList: Array<Argument.AsObject>,
}
}
export class ProxyValue extends jspb.Message {
getId(): number;
setId(value: number): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): ProxyValue.AsObject;
static toObject(includeInstance: boolean, msg: ProxyValue): ProxyValue.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: ProxyValue, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): ProxyValue;
static deserializeBinaryFromReader(message: ProxyValue, reader: jspb.BinaryReader): ProxyValue;
}
export namespace ProxyValue {
export type AsObject = {
id: number,
}
}
export class FunctionValue extends jspb.Message {
getId(): number;
setId(value: number): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): FunctionValue.AsObject;
static toObject(includeInstance: boolean, msg: FunctionValue): FunctionValue.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: FunctionValue, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): FunctionValue;
static deserializeBinaryFromReader(message: FunctionValue, reader: jspb.BinaryReader): FunctionValue;
}
export namespace FunctionValue {
export type AsObject = {
id: number,
}
}
export class NullValue extends jspb.Message {
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): NullValue.AsObject;
static toObject(includeInstance: boolean, msg: NullValue): NullValue.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: NullValue, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): NullValue;
static deserializeBinaryFromReader(message: NullValue, reader: jspb.BinaryReader): NullValue;
}
export namespace NullValue {
export type AsObject = {
}
}
export class UndefinedValue extends jspb.Message {
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): UndefinedValue.AsObject;
static toObject(includeInstance: boolean, msg: UndefinedValue): UndefinedValue.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: UndefinedValue, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): UndefinedValue;
static deserializeBinaryFromReader(message: UndefinedValue, reader: jspb.BinaryReader): UndefinedValue;
}
export namespace UndefinedValue {
export type AsObject = {
}
}
export enum MsgCase {
MSG_NOT_SET = 0,
ERROR = 1,
BUFFER = 2,
OBJECT = 3,
ARRAY = 4,
PROXY = 5,
FUNCTION = 6,
NULL = 7,
UNDEFINED = 8,
NUMBER = 9,
STRING = 10,
BOOLEAN = 11,
}
}
export class Method extends jspb.Message {
hasNamedProxy(): boolean;
clearNamedProxy(): void;
getNamedProxy(): Method.Named | undefined;
setNamedProxy(value?: Method.Named): void;
hasNumberedProxy(): boolean;
clearNumberedProxy(): void;
getNumberedProxy(): Method.Numbered | undefined;
setNumberedProxy(value?: Method.Numbered): void;
getMsgCase(): Method.MsgCase;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): Method.AsObject;
static toObject(includeInstance: boolean, msg: Method): Method.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: Method, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): Method;
static deserializeBinaryFromReader(message: Method, reader: jspb.BinaryReader): Method;
}
export namespace Method {
export type AsObject = {
namedProxy?: Method.Named.AsObject,
numberedProxy?: Method.Numbered.AsObject,
}
export class Named extends jspb.Message {
getId(): number; getId(): number;
setId(value: number): void; setId(value: number): void;
@ -14,30 +303,30 @@ export class NamedProxyMessage extends jspb.Message {
setMethod(value: string): void; setMethod(value: string): void;
clearArgsList(): void; clearArgsList(): void;
getArgsList(): Array<string>; getArgsList(): Array<Argument>;
setArgsList(value: Array<string>): void; setArgsList(value: Array<Argument>): void;
addArgs(value: string, index?: number): string; addArgs(value?: Argument, index?: number): Argument;
serializeBinary(): Uint8Array; serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): NamedProxyMessage.AsObject; toObject(includeInstance?: boolean): Named.AsObject;
static toObject(includeInstance: boolean, msg: NamedProxyMessage): NamedProxyMessage.AsObject; static toObject(includeInstance: boolean, msg: Named): Named.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>}; static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>}; static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: NamedProxyMessage, writer: jspb.BinaryWriter): void; static serializeBinaryToWriter(message: Named, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): NamedProxyMessage; static deserializeBinary(bytes: Uint8Array): Named;
static deserializeBinaryFromReader(message: NamedProxyMessage, reader: jspb.BinaryReader): NamedProxyMessage; static deserializeBinaryFromReader(message: Named, reader: jspb.BinaryReader): Named;
} }
export namespace NamedProxyMessage { export namespace Named {
export type AsObject = { export type AsObject = {
id: number, id: number,
module: Module, module: Module,
method: string, method: string,
argsList: Array<string>, argsList: Array<Argument.AsObject>,
}
} }
}
export class NumberedProxyMessage extends jspb.Message { export class Numbered extends jspb.Message {
getId(): number; getId(): number;
setId(value: number): void; setId(value: number): void;
@ -48,55 +337,79 @@ export class NumberedProxyMessage extends jspb.Message {
setMethod(value: string): void; setMethod(value: string): void;
clearArgsList(): void; clearArgsList(): void;
getArgsList(): Array<string>; getArgsList(): Array<Argument>;
setArgsList(value: Array<string>): void; setArgsList(value: Array<Argument>): void;
addArgs(value: string, index?: number): string; addArgs(value?: Argument, index?: number): Argument;
serializeBinary(): Uint8Array; serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): NumberedProxyMessage.AsObject; toObject(includeInstance?: boolean): Numbered.AsObject;
static toObject(includeInstance: boolean, msg: NumberedProxyMessage): NumberedProxyMessage.AsObject; static toObject(includeInstance: boolean, msg: Numbered): Numbered.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>}; static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>}; static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: NumberedProxyMessage, writer: jspb.BinaryWriter): void; static serializeBinaryToWriter(message: Numbered, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): NumberedProxyMessage; static deserializeBinary(bytes: Uint8Array): Numbered;
static deserializeBinaryFromReader(message: NumberedProxyMessage, reader: jspb.BinaryReader): NumberedProxyMessage; static deserializeBinaryFromReader(message: Numbered, reader: jspb.BinaryReader): Numbered;
} }
export namespace NumberedProxyMessage { export namespace Numbered {
export type AsObject = { export type AsObject = {
id: number, id: number,
proxyId: number, proxyId: number,
method: string, method: string,
argsList: Array<string>, argsList: Array<Argument.AsObject>,
}
} }
}
export class MethodMessage extends jspb.Message { export class Fail extends jspb.Message {
hasNamedProxy(): boolean; getId(): number;
clearNamedProxy(): void; setId(value: number): void;
getNamedProxy(): NamedProxyMessage | undefined;
setNamedProxy(value?: NamedProxyMessage): void;
hasNumberedProxy(): boolean; hasResponse(): boolean;
clearNumberedProxy(): void; clearResponse(): void;
getNumberedProxy(): NumberedProxyMessage | undefined; getResponse(): Argument | undefined;
setNumberedProxy(value?: NumberedProxyMessage): void; setResponse(value?: Argument): void;
getMsgCase(): MethodMessage.MsgCase;
serializeBinary(): Uint8Array; serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): MethodMessage.AsObject; toObject(includeInstance?: boolean): Fail.AsObject;
static toObject(includeInstance: boolean, msg: MethodMessage): MethodMessage.AsObject; static toObject(includeInstance: boolean, msg: Fail): Fail.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>}; static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>}; static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: MethodMessage, writer: jspb.BinaryWriter): void; static serializeBinaryToWriter(message: Fail, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): MethodMessage; static deserializeBinary(bytes: Uint8Array): Fail;
static deserializeBinaryFromReader(message: MethodMessage, reader: jspb.BinaryReader): MethodMessage; static deserializeBinaryFromReader(message: Fail, reader: jspb.BinaryReader): Fail;
} }
export namespace MethodMessage { export namespace Fail {
export type AsObject = { export type AsObject = {
namedProxy?: NamedProxyMessage.AsObject, id: number,
numberedProxy?: NumberedProxyMessage.AsObject, response?: Argument.AsObject,
}
}
export class Success extends jspb.Message {
getId(): number;
setId(value: number): void;
hasResponse(): boolean;
clearResponse(): void;
getResponse(): Argument | undefined;
setResponse(value?: Argument): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): Success.AsObject;
static toObject(includeInstance: boolean, msg: Success): Success.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: Success, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): Success;
static deserializeBinaryFromReader(message: Success, reader: jspb.BinaryReader): Success;
}
export namespace Success {
export type AsObject = {
id: number,
response?: Argument.AsObject,
}
} }
export enum MsgCase { export enum MsgCase {
@ -106,32 +419,92 @@ export namespace MethodMessage {
} }
} }
export class CallbackMessage extends jspb.Message { export class Callback extends jspb.Message {
hasNamedCallback(): boolean; hasNamedCallback(): boolean;
clearNamedCallback(): void; clearNamedCallback(): void;
getNamedCallback(): NamedCallbackMessage | undefined; getNamedCallback(): Callback.Named | undefined;
setNamedCallback(value?: NamedCallbackMessage): void; setNamedCallback(value?: Callback.Named): void;
hasNumberedCallback(): boolean; hasNumberedCallback(): boolean;
clearNumberedCallback(): void; clearNumberedCallback(): void;
getNumberedCallback(): NumberedCallbackMessage | undefined; getNumberedCallback(): Callback.Numbered | undefined;
setNumberedCallback(value?: NumberedCallbackMessage): void; setNumberedCallback(value?: Callback.Numbered): void;
getMsgCase(): CallbackMessage.MsgCase; getMsgCase(): Callback.MsgCase;
serializeBinary(): Uint8Array; serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): CallbackMessage.AsObject; toObject(includeInstance?: boolean): Callback.AsObject;
static toObject(includeInstance: boolean, msg: CallbackMessage): CallbackMessage.AsObject; static toObject(includeInstance: boolean, msg: Callback): Callback.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>}; static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>}; static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: CallbackMessage, writer: jspb.BinaryWriter): void; static serializeBinaryToWriter(message: Callback, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): CallbackMessage; static deserializeBinary(bytes: Uint8Array): Callback;
static deserializeBinaryFromReader(message: CallbackMessage, reader: jspb.BinaryReader): CallbackMessage; static deserializeBinaryFromReader(message: Callback, reader: jspb.BinaryReader): Callback;
} }
export namespace CallbackMessage { export namespace Callback {
export type AsObject = { export type AsObject = {
namedCallback?: NamedCallbackMessage.AsObject, namedCallback?: Callback.Named.AsObject,
numberedCallback?: NumberedCallbackMessage.AsObject, numberedCallback?: Callback.Numbered.AsObject,
}
export class Named extends jspb.Message {
getModule(): Module;
setModule(value: Module): void;
getCallbackId(): number;
setCallbackId(value: number): void;
clearArgsList(): void;
getArgsList(): Array<Argument>;
setArgsList(value: Array<Argument>): void;
addArgs(value?: Argument, index?: number): Argument;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): Named.AsObject;
static toObject(includeInstance: boolean, msg: Named): Named.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: Named, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): Named;
static deserializeBinaryFromReader(message: Named, reader: jspb.BinaryReader): Named;
}
export namespace Named {
export type AsObject = {
module: Module,
callbackId: number,
argsList: Array<Argument.AsObject>,
}
}
export class Numbered extends jspb.Message {
getProxyId(): number;
setProxyId(value: number): void;
getCallbackId(): number;
setCallbackId(value: number): void;
clearArgsList(): void;
getArgsList(): Array<Argument>;
setArgsList(value: Array<Argument>): void;
addArgs(value?: Argument, index?: number): Argument;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): Numbered.AsObject;
static toObject(includeInstance: boolean, msg: Numbered): Numbered.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: Numbered, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): Numbered;
static deserializeBinaryFromReader(message: Numbered, reader: jspb.BinaryReader): Numbered;
}
export namespace Numbered {
export type AsObject = {
proxyId: number,
callbackId: number,
argsList: Array<Argument.AsObject>,
}
} }
export enum MsgCase { export enum MsgCase {
@ -141,92 +514,92 @@ export namespace CallbackMessage {
} }
} }
export class NamedCallbackMessage extends jspb.Message { export class Event extends jspb.Message {
getModule(): Module;
setModule(value: Module): void;
getCallbackId(): number;
setCallbackId(value: number): void;
clearArgsList(): void;
getArgsList(): Array<string>;
setArgsList(value: Array<string>): void;
addArgs(value: string, index?: number): string;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): NamedCallbackMessage.AsObject;
static toObject(includeInstance: boolean, msg: NamedCallbackMessage): NamedCallbackMessage.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: NamedCallbackMessage, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): NamedCallbackMessage;
static deserializeBinaryFromReader(message: NamedCallbackMessage, reader: jspb.BinaryReader): NamedCallbackMessage;
}
export namespace NamedCallbackMessage {
export type AsObject = {
module: Module,
callbackId: number,
argsList: Array<string>,
}
}
export class NumberedCallbackMessage extends jspb.Message {
getProxyId(): number;
setProxyId(value: number): void;
getCallbackId(): number;
setCallbackId(value: number): void;
clearArgsList(): void;
getArgsList(): Array<string>;
setArgsList(value: Array<string>): void;
addArgs(value: string, index?: number): string;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): NumberedCallbackMessage.AsObject;
static toObject(includeInstance: boolean, msg: NumberedCallbackMessage): NumberedCallbackMessage.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: NumberedCallbackMessage, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): NumberedCallbackMessage;
static deserializeBinaryFromReader(message: NumberedCallbackMessage, reader: jspb.BinaryReader): NumberedCallbackMessage;
}
export namespace NumberedCallbackMessage {
export type AsObject = {
proxyId: number,
callbackId: number,
argsList: Array<string>,
}
}
export class EventMessage extends jspb.Message {
hasNamedEvent(): boolean; hasNamedEvent(): boolean;
clearNamedEvent(): void; clearNamedEvent(): void;
getNamedEvent(): NamedEventMessage | undefined; getNamedEvent(): Event.Named | undefined;
setNamedEvent(value?: NamedEventMessage): void; setNamedEvent(value?: Event.Named): void;
hasNumberedEvent(): boolean; hasNumberedEvent(): boolean;
clearNumberedEvent(): void; clearNumberedEvent(): void;
getNumberedEvent(): NumberedEventMessage | undefined; getNumberedEvent(): Event.Numbered | undefined;
setNumberedEvent(value?: NumberedEventMessage): void; setNumberedEvent(value?: Event.Numbered): void;
getMsgCase(): EventMessage.MsgCase; getMsgCase(): Event.MsgCase;
serializeBinary(): Uint8Array; serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): EventMessage.AsObject; toObject(includeInstance?: boolean): Event.AsObject;
static toObject(includeInstance: boolean, msg: EventMessage): EventMessage.AsObject; static toObject(includeInstance: boolean, msg: Event): Event.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>}; static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>}; static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: EventMessage, writer: jspb.BinaryWriter): void; static serializeBinaryToWriter(message: Event, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): EventMessage; static deserializeBinary(bytes: Uint8Array): Event;
static deserializeBinaryFromReader(message: EventMessage, reader: jspb.BinaryReader): EventMessage; static deserializeBinaryFromReader(message: Event, reader: jspb.BinaryReader): Event;
} }
export namespace EventMessage { export namespace Event {
export type AsObject = { export type AsObject = {
namedEvent?: NamedEventMessage.AsObject, namedEvent?: Event.Named.AsObject,
numberedEvent?: NumberedEventMessage.AsObject, numberedEvent?: Event.Numbered.AsObject,
}
export class Named extends jspb.Message {
getModule(): Module;
setModule(value: Module): void;
getEvent(): string;
setEvent(value: string): void;
clearArgsList(): void;
getArgsList(): Array<Argument>;
setArgsList(value: Array<Argument>): void;
addArgs(value?: Argument, index?: number): Argument;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): Named.AsObject;
static toObject(includeInstance: boolean, msg: Named): Named.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: Named, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): Named;
static deserializeBinaryFromReader(message: Named, reader: jspb.BinaryReader): Named;
}
export namespace Named {
export type AsObject = {
module: Module,
event: string,
argsList: Array<Argument.AsObject>,
}
}
export class Numbered extends jspb.Message {
getProxyId(): number;
setProxyId(value: number): void;
getEvent(): string;
setEvent(value: string): void;
clearArgsList(): void;
getArgsList(): Array<Argument>;
setArgsList(value: Array<Argument>): void;
addArgs(value?: Argument, index?: number): Argument;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): Numbered.AsObject;
static toObject(includeInstance: boolean, msg: Numbered): Numbered.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: Numbered, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): Numbered;
static deserializeBinaryFromReader(message: Numbered, reader: jspb.BinaryReader): Numbered;
}
export namespace Numbered {
export type AsObject = {
proxyId: number,
event: string,
argsList: Array<Argument.AsObject>,
}
} }
export enum MsgCase { export enum MsgCase {
@ -236,114 +609,6 @@ export namespace EventMessage {
} }
} }
export class NamedEventMessage extends jspb.Message {
getModule(): Module;
setModule(value: Module): void;
getEvent(): string;
setEvent(value: string): void;
clearArgsList(): void;
getArgsList(): Array<string>;
setArgsList(value: Array<string>): void;
addArgs(value: string, index?: number): string;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): NamedEventMessage.AsObject;
static toObject(includeInstance: boolean, msg: NamedEventMessage): NamedEventMessage.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: NamedEventMessage, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): NamedEventMessage;
static deserializeBinaryFromReader(message: NamedEventMessage, reader: jspb.BinaryReader): NamedEventMessage;
}
export namespace NamedEventMessage {
export type AsObject = {
module: Module,
event: string,
argsList: Array<string>,
}
}
export class NumberedEventMessage extends jspb.Message {
getProxyId(): number;
setProxyId(value: number): void;
getEvent(): string;
setEvent(value: string): void;
clearArgsList(): void;
getArgsList(): Array<string>;
setArgsList(value: Array<string>): void;
addArgs(value: string, index?: number): string;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): NumberedEventMessage.AsObject;
static toObject(includeInstance: boolean, msg: NumberedEventMessage): NumberedEventMessage.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: NumberedEventMessage, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): NumberedEventMessage;
static deserializeBinaryFromReader(message: NumberedEventMessage, reader: jspb.BinaryReader): NumberedEventMessage;
}
export namespace NumberedEventMessage {
export type AsObject = {
proxyId: number,
event: string,
argsList: Array<string>,
}
}
export class FailMessage extends jspb.Message {
getId(): number;
setId(value: number): void;
getResponse(): string;
setResponse(value: string): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): FailMessage.AsObject;
static toObject(includeInstance: boolean, msg: FailMessage): FailMessage.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: FailMessage, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): FailMessage;
static deserializeBinaryFromReader(message: FailMessage, reader: jspb.BinaryReader): FailMessage;
}
export namespace FailMessage {
export type AsObject = {
id: number,
response: string,
}
}
export class SuccessMessage extends jspb.Message {
getId(): number;
setId(value: number): void;
getResponse(): string;
setResponse(value: string): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): SuccessMessage.AsObject;
static toObject(includeInstance: boolean, msg: SuccessMessage): SuccessMessage.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: SuccessMessage, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): SuccessMessage;
static deserializeBinaryFromReader(message: SuccessMessage, reader: jspb.BinaryReader): SuccessMessage;
}
export namespace SuccessMessage {
export type AsObject = {
id: number,
response: string,
}
}
export class Ping extends jspb.Message { export class Ping extends jspb.Message {
serializeBinary(): Uint8Array; serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): Ping.AsObject; toObject(includeInstance?: boolean): Ping.AsObject;

6753
packages/protocol/src/proto/node_pb.js
View File

File diff suppressed because it is too large Load Diff

2
packages/protocol/src/proto/vscode.proto
View File

@ -1,7 +1,7 @@
syntax = "proto3"; syntax = "proto3";
// Sent when a shared process becomes active // Sent when a shared process becomes active
message SharedProcessActiveMessage { message SharedProcessActive {
string socket_path = 1; string socket_path = 1;
string log_path = 2; string log_path = 2;
} }

14
packages/protocol/src/proto/vscode_pb.d.ts vendored
View File

@ -3,7 +3,7 @@
import * as jspb from "google-protobuf"; import * as jspb from "google-protobuf";
export class SharedProcessActiveMessage extends jspb.Message { export class SharedProcessActive extends jspb.Message {
getSocketPath(): string; getSocketPath(): string;
setSocketPath(value: string): void; setSocketPath(value: string): void;
@ -11,16 +11,16 @@ export class SharedProcessActiveMessage extends jspb.Message {
setLogPath(value: string): void; setLogPath(value: string): void;
serializeBinary(): Uint8Array; serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): SharedProcessActiveMessage.AsObject; toObject(includeInstance?: boolean): SharedProcessActive.AsObject;
static toObject(includeInstance: boolean, msg: SharedProcessActiveMessage): SharedProcessActiveMessage.AsObject; static toObject(includeInstance: boolean, msg: SharedProcessActive): SharedProcessActive.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>}; static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>}; static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: SharedProcessActiveMessage, writer: jspb.BinaryWriter): void; static serializeBinaryToWriter(message: SharedProcessActive, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): SharedProcessActiveMessage; static deserializeBinary(bytes: Uint8Array): SharedProcessActive;
static deserializeBinaryFromReader(message: SharedProcessActiveMessage, reader: jspb.BinaryReader): SharedProcessActiveMessage; static deserializeBinaryFromReader(message: SharedProcessActive, reader: jspb.BinaryReader): SharedProcessActive;
} }
export namespace SharedProcessActiveMessage { export namespace SharedProcessActive {
export type AsObject = { export type AsObject = {
socketPath: string, socketPath: string,
logPath: string, logPath: string,

54
packages/protocol/src/proto/vscode_pb.js
View File

@ -11,8 +11,7 @@ var jspb = require('google-protobuf');
var goog = jspb; var goog = jspb;
var global = Function('return this')(); var global = Function('return this')();
goog.exportSymbol('proto.SharedProcessActiveMessage', null, global); goog.exportSymbol('proto.SharedProcessActive', null, global);
/** /**
* Generated by JsPbCodeGenerator. * Generated by JsPbCodeGenerator.
* @param {Array=} opt_data Optional initial data array, typically from a * @param {Array=} opt_data Optional initial data array, typically from a
@ -23,15 +22,20 @@ goog.exportSymbol('proto.SharedProcessActiveMessage', null, global);
* @extends {jspb.Message} * @extends {jspb.Message}
* @constructor * @constructor
*/ */
proto.SharedProcessActiveMessage = function(opt_data) { proto.SharedProcessActive = function(opt_data) {
jspb.Message.initialize(this, opt_data, 0, -1, null, null); jspb.Message.initialize(this, opt_data, 0, -1, null, null);
}; };
goog.inherits(proto.SharedProcessActiveMessage, jspb.Message); goog.inherits(proto.SharedProcessActive, jspb.Message);
if (goog.DEBUG && !COMPILED) { if (goog.DEBUG && !COMPILED) {
proto.SharedProcessActiveMessage.displayName = 'proto.SharedProcessActiveMessage'; /**
* @public
* @override
*/
proto.SharedProcessActive.displayName = 'proto.SharedProcessActive';
} }
if (jspb.Message.GENERATE_TO_OBJECT) { if (jspb.Message.GENERATE_TO_OBJECT) {
/** /**
* Creates an object representation of this proto suitable for use in Soy templates. * Creates an object representation of this proto suitable for use in Soy templates.
@ -43,8 +47,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) {
* for transitional soy proto support: http://goto/soy-param-migration * for transitional soy proto support: http://goto/soy-param-migration
* @return {!Object} * @return {!Object}
*/ */
proto.SharedProcessActiveMessage.prototype.toObject = function(opt_includeInstance) { proto.SharedProcessActive.prototype.toObject = function(opt_includeInstance) {
return proto.SharedProcessActiveMessage.toObject(opt_includeInstance, this); return proto.SharedProcessActive.toObject(opt_includeInstance, this);
}; };
@ -53,12 +57,12 @@ proto.SharedProcessActiveMessage.prototype.toObject = function(opt_includeInstan
* @param {boolean|undefined} includeInstance Whether to include the JSPB * @param {boolean|undefined} includeInstance Whether to include the JSPB
* instance for transitional soy proto support: * instance for transitional soy proto support:
* http://goto/soy-param-migration * http://goto/soy-param-migration
* @param {!proto.SharedProcessActiveMessage} msg The msg instance to transform. * @param {!proto.SharedProcessActive} msg The msg instance to transform.
* @return {!Object} * @return {!Object}
* @suppress {unusedLocalVariables} f is only used for nested messages * @suppress {unusedLocalVariables} f is only used for nested messages
*/ */
proto.SharedProcessActiveMessage.toObject = function(includeInstance, msg) { proto.SharedProcessActive.toObject = function(includeInstance, msg) {
var f, obj = { var obj = {
socketPath: jspb.Message.getFieldWithDefault(msg, 1, ""), socketPath: jspb.Message.getFieldWithDefault(msg, 1, ""),
logPath: jspb.Message.getFieldWithDefault(msg, 2, "") logPath: jspb.Message.getFieldWithDefault(msg, 2, "")
}; };
@ -74,23 +78,23 @@ proto.SharedProcessActiveMessage.toObject = function(includeInstance, msg) {
/** /**
* Deserializes binary data (in protobuf wire format). * Deserializes binary data (in protobuf wire format).
* @param {jspb.ByteSource} bytes The bytes to deserialize. * @param {jspb.ByteSource} bytes The bytes to deserialize.
* @return {!proto.SharedProcessActiveMessage} * @return {!proto.SharedProcessActive}
*/ */
proto.SharedProcessActiveMessage.deserializeBinary = function(bytes) { proto.SharedProcessActive.deserializeBinary = function(bytes) {
var reader = new jspb.BinaryReader(bytes); var reader = new jspb.BinaryReader(bytes);
var msg = new proto.SharedProcessActiveMessage; var msg = new proto.SharedProcessActive;
return proto.SharedProcessActiveMessage.deserializeBinaryFromReader(msg, reader); return proto.SharedProcessActive.deserializeBinaryFromReader(msg, reader);
}; };
/** /**
* Deserializes binary data (in protobuf wire format) from the * Deserializes binary data (in protobuf wire format) from the
* given reader into the given message object. * given reader into the given message object.
* @param {!proto.SharedProcessActiveMessage} msg The message object to deserialize into. * @param {!proto.SharedProcessActive} msg The message object to deserialize into.
* @param {!jspb.BinaryReader} reader The BinaryReader to use. * @param {!jspb.BinaryReader} reader The BinaryReader to use.
* @return {!proto.SharedProcessActiveMessage} * @return {!proto.SharedProcessActive}
*/ */
proto.SharedProcessActiveMessage.deserializeBinaryFromReader = function(msg, reader) { proto.SharedProcessActive.deserializeBinaryFromReader = function(msg, reader) {
while (reader.nextField()) { while (reader.nextField()) {
if (reader.isEndGroup()) { if (reader.isEndGroup()) {
break; break;
@ -118,9 +122,9 @@ proto.SharedProcessActiveMessage.deserializeBinaryFromReader = function(msg, rea
* Serializes the message to binary data (in protobuf wire format). * Serializes the message to binary data (in protobuf wire format).
* @return {!Uint8Array} * @return {!Uint8Array}
*/ */
proto.SharedProcessActiveMessage.prototype.serializeBinary = function() { proto.SharedProcessActive.prototype.serializeBinary = function() {
var writer = new jspb.BinaryWriter(); var writer = new jspb.BinaryWriter();
proto.SharedProcessActiveMessage.serializeBinaryToWriter(this, writer); proto.SharedProcessActive.serializeBinaryToWriter(this, writer);
return writer.getResultBuffer(); return writer.getResultBuffer();
}; };
@ -128,11 +132,11 @@ proto.SharedProcessActiveMessage.prototype.serializeBinary = function() {
/** /**
* Serializes the given message to binary data (in protobuf wire * Serializes the given message to binary data (in protobuf wire
* format), writing to the given BinaryWriter. * format), writing to the given BinaryWriter.
* @param {!proto.SharedProcessActiveMessage} message * @param {!proto.SharedProcessActive} message
* @param {!jspb.BinaryWriter} writer * @param {!jspb.BinaryWriter} writer
* @suppress {unusedLocalVariables} f is only used for nested messages * @suppress {unusedLocalVariables} f is only used for nested messages
*/ */
proto.SharedProcessActiveMessage.serializeBinaryToWriter = function(message, writer) { proto.SharedProcessActive.serializeBinaryToWriter = function(message, writer) {
var f = undefined; var f = undefined;
f = message.getSocketPath(); f = message.getSocketPath();
if (f.length > 0) { if (f.length > 0) {
@ -155,13 +159,13 @@ proto.SharedProcessActiveMessage.serializeBinaryToWriter = function(message, wri
* optional string socket_path = 1; * optional string socket_path = 1;
* @return {string} * @return {string}
*/ */
proto.SharedProcessActiveMessage.prototype.getSocketPath = function() { proto.SharedProcessActive.prototype.getSocketPath = function() {
return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, ""));
}; };
/** @param {string} value */ /** @param {string} value */
proto.SharedProcessActiveMessage.prototype.setSocketPath = function(value) { proto.SharedProcessActive.prototype.setSocketPath = function(value) {
jspb.Message.setProto3StringField(this, 1, value); jspb.Message.setProto3StringField(this, 1, value);
}; };
@ -170,13 +174,13 @@ proto.SharedProcessActiveMessage.prototype.setSocketPath = function(value) {
* optional string log_path = 2; * optional string log_path = 2;
* @return {string} * @return {string}
*/ */
proto.SharedProcessActiveMessage.prototype.getLogPath = function() { proto.SharedProcessActive.prototype.getLogPath = function() {
return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, ""));
}; };
/** @param {string} value */ /** @param {string} value */
proto.SharedProcessActiveMessage.prototype.setLogPath = function(value) { proto.SharedProcessActive.prototype.setLogPath = function(value) {
jspb.Message.setProto3StringField(this, 2, value); jspb.Message.setProto3StringField(this, 2, value);
}; };

6
packages/protocol/test/child_process.test.ts
View File

@ -10,7 +10,7 @@ describe("child_process", () => {
const cp = client.modules[Module.ChildProcess]; const cp = client.modules[Module.ChildProcess];
const getStdout = async (proc: ChildProcess): Promise<string> => { const getStdout = async (proc: ChildProcess): Promise<string> => {
return new Promise((r): Readable => proc.stdout.on("data", r)) return new Promise((r): Readable => proc.stdout!.on("data", r))
.then((s) => s.toString()); .then((s) => s.toString());
}; };
@ -36,10 +36,10 @@ describe("child_process", () => {
it("should cat", async () => { it("should cat", async () => {
const proc = cp.spawn("cat", []); const proc = cp.spawn("cat", []);
expect(proc.pid).toBe(-1); expect(proc.pid).toBe(-1);
proc.stdin.write("banana"); proc.stdin!.write("banana");
await expect(getStdout(proc)).resolves.toBe("banana"); await expect(getStdout(proc)).resolves.toBe("banana");
proc.stdin.end(); proc.stdin!.end();
proc.kill(); proc.kill();
expect(proc.pid).toBeGreaterThan(-1); expect(proc.pid).toBeGreaterThan(-1);

6
packages/protocol/test/server.test.ts
View File

@ -12,12 +12,10 @@ describe("Server", () => {
workingDirectory, workingDirectory,
}); });
it("should get init msg", (done) => { it("should get init msg", async () => {
client.initData.then((data) => { const data = await client.initData;
expect(data.dataDirectory).toEqual(dataDirectory); expect(data.dataDirectory).toEqual(dataDirectory);
expect(data.workingDirectory).toEqual(workingDirectory); expect(data.workingDirectory).toEqual(workingDirectory);
expect(data.builtInExtensionsDirectory).toEqual(builtInExtensionsDirectory); expect(data.builtInExtensionsDirectory).toEqual(builtInExtensionsDirectory);
done();
});
}); });
}); });

101
packages/protocol/test/util.test.ts Normal file
View File

@ -0,0 +1,101 @@
import * as fs from "fs";
import * as util from "util";
import { argumentToProto, protoToArgument } from "../src/common/util";
describe("Convert", () => {
it("should convert nothing", () => {
expect(protoToArgument()).toBeUndefined();
});
it("should convert null", () => {
expect(protoToArgument(argumentToProto(null))).toBeNull();
});
it("should convert undefined", () => {
expect(protoToArgument(argumentToProto(undefined))).toBeUndefined();
});
it("should convert string", () => {
expect(protoToArgument(argumentToProto("test"))).toBe("test");
});
it("should convert number", () => {
expect(protoToArgument(argumentToProto(10))).toBe(10);
});
it("should convert boolean", () => {
expect(protoToArgument(argumentToProto(true))).toBe(true);
expect(protoToArgument(argumentToProto(false))).toBe(false);
});
it("should convert error", () => {
const error = new Error("message");
const convertedError = protoToArgument(argumentToProto(error));
expect(convertedError instanceof Error).toBeTruthy();
expect(convertedError.message).toBe("message");
});
it("should convert buffer", async () => {
const buffer = await util.promisify(fs.readFile)(__filename);
expect(buffer instanceof Buffer).toBeTruthy();
const convertedBuffer = protoToArgument(argumentToProto(buffer));
expect(convertedBuffer instanceof Buffer).toBeTruthy();
expect(convertedBuffer.toString()).toBe(buffer.toString());
});
it("should convert proxy", () => {
let i = 0;
const proto = argumentToProto(
{ onEvent: (): void => undefined },
undefined,
() => i++,
);
const proxy = protoToArgument(proto, undefined, (id) => {
return {
id: `created: ${id}`,
dispose: (): Promise<void> => Promise.resolve(),
onDone: (): Promise<void> => Promise.resolve(),
onEvent: (): Promise<void> => Promise.resolve(),
};
});
expect(proxy.id).toBe("created: 0");
});
it("should convert function", () => {
const fn = jest.fn();
// tslint:disable-next-line no-any
const map = new Map<number, (...args: any[]) => void>();
let i = 0;
const proto = argumentToProto(
fn,
(f) => {
map.set(i++, f);
return i - 1;
},
);
const remoteFn = protoToArgument(proto, (id, args) => {
map.get(id)!(...args);
});
remoteFn("a", "b", 1);
expect(fn).toHaveBeenCalledWith("a", "b", 1);
});
it("should convert array", () => {
const array = ["a", "b", 1, [1, "a"], null, undefined];
expect(protoToArgument(argumentToProto(array))).toEqual(array);
});
it("should convert object", () => {
const obj = { a: "test" };
// const obj = { "a": 1, "b": [1, "a"], test: null, test2: undefined };
expect(protoToArgument(argumentToProto(obj))).toEqual(obj);
});
});

4
packages/server/src/cli.ts
View File

@ -1,5 +1,5 @@
import { field, logger } from "@coder/logger"; import { field, logger } from "@coder/logger";
import { ServerMessage, SharedProcessActiveMessage } from "@coder/protocol/src/proto"; import { ServerMessage, SharedProcessActive } from "@coder/protocol/src/proto";
import { ChildProcess, fork, ForkOptions, spawn } from "child_process"; import { ChildProcess, fork, ForkOptions, spawn } from "child_process";
import { randomFillSync } from "crypto"; import { randomFillSync } from "crypto";
import * as fs from "fs"; import * as fs from "fs";
@ -145,7 +145,7 @@ if (isCli) {
logger.info("Initializing", field("data-dir", dataDir), field("working-dir", workingDir), field("log-dir", logDir)); logger.info("Initializing", field("data-dir", dataDir), field("working-dir", workingDir), field("log-dir", logDir));
const sharedProcess = new SharedProcess(dataDir, builtInExtensionsDir); const sharedProcess = new SharedProcess(dataDir, builtInExtensionsDir);
const sendSharedProcessReady = (socket: WebSocket): void => { const sendSharedProcessReady = (socket: WebSocket): void => {
const active = new SharedProcessActiveMessage(); const active = new SharedProcessActive();
active.setSocketPath(sharedProcess.socketPath); active.setSocketPath(sharedProcess.socketPath);
active.setLogPath(logDir); active.setLogPath(logDir);
const serverMessage = new ServerMessage(); const serverMessage = new ServerMessage();