@adminide-stack/extension-api 0.0.2-alpha.0

package/lib/protocol/rpc-protocol.js

@@ -0,0 +1,750 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArgType = exports.MessageType = exports.MessageIO = exports.MessageBuffer = exports.RPCProtocol = exports.ResponsiveState = exports.RequestInitiator = exports.safeStringify = void 0;
+/* tslint:disable */
+const async_1 = require("@vscode-alt/monaco-editor/esm/vs/base/common/async");
+const cancellation_1 = require("@vscode-alt/monaco-editor/esm/vs/base/common/cancellation");
+const errors = require("@vscode-alt/monaco-editor/esm/vs/base/common/errors");
+const event_1 = require("@vscode-alt/monaco-editor/esm/vs/base/common/event");
+const lifecycle_1 = require("@vscode-alt/monaco-editor/esm/vs/base/common/lifecycle");
+const uriIpc_1 = require("@vscode-alt/monaco-editor/esm/vs/base/common/uriIpc");
+const utils_1 = require("./utils");
+const proxy_identifier_1 = require("./proxy-identifier");
+const buffer_1 = require("@vscode-alt/monaco-editor/esm/vs/base/common/buffer");
+function safeStringify(obj, replacer) {
+    try {
+        return JSON.stringify(obj, replacer);
+    }
+    catch (err) {
+        return 'null';
+    }
+}
+exports.safeStringify = safeStringify;
+function createURIReplacer(transformer) {
+    if (!transformer) {
+        return null;
+    }
+    return (key, value) => {
+        if (value && value.$mid === 1) {
+            return transformer.transformOutgoing(value);
+        }
+        return value;
+    };
+}
+var RequestInitiator;
+(function (RequestInitiator) {
+    RequestInitiator[RequestInitiator["LocalSide"] = 0] = "LocalSide";
+    RequestInitiator[RequestInitiator["OtherSide"] = 1] = "OtherSide";
+})(RequestInitiator = exports.RequestInitiator || (exports.RequestInitiator = {}));
+var ResponsiveState;
+(function (ResponsiveState) {
+    ResponsiveState[ResponsiveState["Responsive"] = 0] = "Responsive";
+    ResponsiveState[ResponsiveState["Unresponsive"] = 1] = "Unresponsive";
+})(ResponsiveState = exports.ResponsiveState || (exports.ResponsiveState = {}));
+const noop = () => { };
+class RPCProtocol extends lifecycle_1.Disposable {
+    constructor(protocol, _localHostId = null, logger = null, transformer = null) {
+        super();
+        this._onDidChangeResponsiveState = this._register(new event_1.Emitter());
+        this.onDidChangeResponsiveState = this._onDidChangeResponsiveState.event;
+        this.localHostId = _localHostId;
+        this._protocol = protocol;
+        this._logger = logger;
+        this._uriTransformer = transformer;
+        this._uriReplacer = createURIReplacer(this._uriTransformer);
+        this._isDisposed = false;
+        this._locals = [];
+        this._proxies = [];
+        for (let i = 0, len = proxy_identifier_1.ProxyIdentifier.count; i < len; i++) {
+            this._locals[i] = null;
+            this._proxies[i] = null;
+        }
+        this._lastMessageId = 0;
+        this._cancelInvokedHandlers = Object.create(null);
+        this._pendingRPCReplies = {};
+        this._responsiveState = 0 /* ResponsiveState.Responsive */;
+        this._unacknowledgedCount = 0;
+        this._unresponsiveTime = 0;
+        this._asyncCheckUresponsive = this._register(new async_1.RunOnceScheduler(() => this._checkUnresponsive(), 1000));
+        this._protocol.onMessage((msg) => this._receiveOneMessage(msg));
+    }
+    dispose() {
+        this._isDisposed = true;
+        // Release all outstanding promises with a canceled error
+        Object.keys(this._pendingRPCReplies).forEach((msgId) => {
+            const pending = this._pendingRPCReplies[msgId];
+            pending.resolveErr(errors.canceled());
+        });
+    }
+    _onWillSendRequest(req) {
+        if (this._unacknowledgedCount === 0) {
+            // Since this is the first request we are sending in a while,
+            // mark this moment as the start for the countdown to unresponsive time
+            this._unresponsiveTime = Date.now() + RPCProtocol.UNRESPONSIVE_TIME;
+        }
+        this._unacknowledgedCount++;
+        if (!this._asyncCheckUresponsive.isScheduled()) {
+            this._asyncCheckUresponsive.schedule();
+        }
+    }
+    _onDidReceiveAcknowledge(req) {
+        // The next possible unresponsive time is now + delta.
+        this._unresponsiveTime = Date.now() + RPCProtocol.UNRESPONSIVE_TIME;
+        this._unacknowledgedCount--;
+        if (this._unacknowledgedCount === 0) {
+            // No more need to check for unresponsive
+            this._asyncCheckUresponsive.cancel();
+        }
+        // The ext host is responsive!
+        this._setResponsiveState(0 /* ResponsiveState.Responsive */);
+    }
+    _checkUnresponsive() {
+        if (this._unacknowledgedCount === 0) {
+            // Not waiting for anything => cannot say if it is responsive or not
+            return;
+        }
+        if (Date.now() > this._unresponsiveTime) {
+            // Unresponsive!!
+            this._setResponsiveState(1 /* ResponsiveState.Unresponsive */);
+        }
+        else {
+            // Not (yet) unresponsive, be sure to check again soon
+            this._asyncCheckUresponsive.schedule();
+        }
+    }
+    _setResponsiveState(newResponsiveState) {
+        if (this._responsiveState === newResponsiveState) {
+            // no change
+            return;
+        }
+        this._responsiveState = newResponsiveState;
+        this._onDidChangeResponsiveState.fire(this._responsiveState);
+    }
+    get responsiveState() {
+        return this._responsiveState;
+    }
+    transformIncomingURIs(obj) {
+        if (!this._uriTransformer) {
+            return obj;
+        }
+        return (0, uriIpc_1.transformIncomingURIs)(obj, this._uriTransformer);
+    }
+    getProxy(identifier) {
+        const rpcId = identifier.nid;
+        if (!this._proxies[rpcId]) {
+            this._proxies[rpcId] = this._createProxy(rpcId, identifier.hostId);
+        }
+        return this._proxies[rpcId];
+    }
+    _createProxy(rpcId, destId) {
+        let handler = {
+            get: (target, name) => {
+                // @sri due to some issue we need to do this way
+                // if (!target[name] && name.charCodeAt(0) === CharCode.DollarSign) {
+                if (!target[name] && name[0] === '$') {
+                    target[name] = (...myArgs) => {
+                        return this._remoteCall(destId, rpcId, name, myArgs);
+                    };
+                }
+                return target[name];
+            }
+        };
+        return new Proxy(Object.create(null), handler);
+    }
+    set(identifier, value) {
+        this._locals[identifier.nid] = value;
+        return value;
+    }
+    assertRegistered(identifiers) {
+        for (let i = 0, len = identifiers.length; i < len; i++) {
+            const identifier = identifiers[i];
+            if (!this._locals[identifier.nid]) {
+                // @sri to log missing identifier
+                console.log('identifer missing', identifier);
+                throw new Error(`Missing actor ${identifier.sid} (isMain: ${identifier.isMain})`);
+            }
+        }
+    }
+    _receiveOneMessage(rawmsg) {
+        if (this._isDisposed) {
+            return;
+        }
+        let senderHost = null;
+        let destHostId = null;
+        let leadNum = 0;
+        if (this.localHostId !== null) {
+            destHostId = rawmsg.readUInt8(0);
+            if (destHostId !== this.localHostId) {
+                return this._protocol.forward(rawmsg, destHostId);
+            }
+            leadNum = 2;
+            senderHost = rawmsg.readUInt8(1);
+        }
+        const msgLength = rawmsg.byteLength - leadNum;
+        const buff = MessageBuffer.read(rawmsg, leadNum);
+        const messageType = buff.readUInt8();
+        const req = buff.readUInt32();
+        switch (messageType) {
+            case 1 /* MessageType.RequestJSONArgs */:
+            case 2 /* MessageType.RequestJSONArgsWithCancellation */: {
+                let { rpcId, method, args } = MessageIO.deserializeRequestJSONArgs(buff);
+                if (this._uriTransformer) {
+                    args = (0, uriIpc_1.transformIncomingURIs)(args, this._uriTransformer);
+                }
+                // @sri add senderHost for identification
+                this._receiveRequest(senderHost, msgLength, req, rpcId, method, args, (messageType === 2 /* MessageType.RequestJSONArgsWithCancellation */));
+                break;
+            }
+            case 3 /* MessageType.RequestMixedArgs */:
+            case 4 /* MessageType.RequestMixedArgsWithCancellation */: {
+                let { rpcId, method, args } = MessageIO.deserializeRequestMixedArgs(buff);
+                if (this._uriTransformer) {
+                    args = (0, uriIpc_1.transformIncomingURIs)(args, this._uriTransformer);
+                }
+                // @sri add senderHost as identifier
+                this._receiveRequest(senderHost, msgLength, req, rpcId, method, args, (messageType === 4 /* MessageType.RequestMixedArgsWithCancellation */));
+                break;
+            }
+            case 5 /* MessageType.Acknowledged */: {
+                if (this._logger) {
+                    this._logger.logIncoming(msgLength, req, 0 /* RequestInitiator.LocalSide */, `ack`);
+                }
+                this._onDidReceiveAcknowledge(req);
+                break;
+            }
+            case 6 /* MessageType.Cancel */: {
+                this._receiveCancel(msgLength, req);
+                break;
+            }
+            case 7 /* MessageType.ReplyOKEmpty */: {
+                this._receiveReply(msgLength, req, undefined);
+                break;
+            }
+            case 9 /* MessageType.ReplyOKJSON */: {
+                let value = MessageIO.deserializeReplyOKJSON(buff);
+                if (this._uriTransformer) {
+                    value = (0, uriIpc_1.transformIncomingURIs)(value, this._uriTransformer);
+                }
+                this._receiveReply(msgLength, req, value);
+                break;
+            }
+            case 8 /* MessageType.ReplyOKBuffer */: {
+                let value = MessageIO.deserializeReplyOKBuffer(buff);
+                this._receiveReply(msgLength, req, value);
+                break;
+            }
+            case 8 /* MessageType.ReplyOKVSBuffer */: {
+                let value = MessageIO.deserializeReplyOKVSBuffer(buff);
+                this._receiveReply(msgLength, req, value);
+                break;
+            }
+            case 10 /* MessageType.ReplyErrError */: {
+                let err = MessageIO.deserializeReplyErrError(buff);
+                if (this._uriTransformer) {
+                    err = (0, uriIpc_1.transformIncomingURIs)(err, this._uriTransformer);
+                }
+                this._receiveReplyErr(msgLength, req, err);
+                break;
+            }
+            case 11 /* MessageType.ReplyErrEmpty */: {
+                this._receiveReplyErr(msgLength, req, undefined);
+                break;
+            }
+            default:
+                console.error(`received unexpected message`);
+                console.error(rawmsg);
+        }
+    }
+    //@sri added destId for identification
+    _receiveRequest(destId, msgLength, req, rpcId, method, args, usesCancellationToken) {
+        if (this._logger) {
+            this._logger.logIncoming(msgLength, req, 1 /* RequestInitiator.OtherSide */, `receiveRequest ${(0, proxy_identifier_1.getStringIdentifierForProxy)(rpcId)}.${method}(`, args);
+        }
+        const callId = String(req);
+        let promise;
+        let cancel;
+        if (usesCancellationToken) {
+            const cancellationTokenSource = new cancellation_1.CancellationTokenSource();
+            args.push(cancellationTokenSource.token);
+            promise = this._invokeHandler(rpcId, method, args);
+            cancel = () => cancellationTokenSource.cancel();
+        }
+        else {
+            // cannot be cancelled
+            promise = this._invokeHandler(rpcId, method, args);
+            cancel = noop;
+        }
+        this._cancelInvokedHandlers[callId] = cancel;
+        // Acknowledge the request
+        const msg = MessageIO.serializeAcknowledged(req);
+        if (this._logger) {
+            this._logger.logOutgoing(msg.byteLength, req, 1 /* RequestInitiator.OtherSide */, `ack`);
+        }
+        this._protocol.send(msg, destId);
+        promise.then((r) => {
+            delete this._cancelInvokedHandlers[callId];
+            const msg = MessageIO.serializeReplyOK(req, r, this._uriReplacer);
+            if (this._logger) {
+                this._logger.logOutgoing(msg.byteLength, req, 1 /* RequestInitiator.OtherSide */, `reply:`, r);
+            }
+            this._protocol.send(msg, destId);
+        }, (err) => {
+            delete this._cancelInvokedHandlers[callId];
+            const msg = MessageIO.serializeReplyErr(req, err);
+            if (this._logger) {
+                this._logger.logOutgoing(msg.byteLength, req, 1 /* RequestInitiator.OtherSide */, `replyErr:`, err);
+            }
+            this._protocol.send(msg, destId);
+        });
+    }
+    _receiveCancel(msgLength, req) {
+        if (this._logger) {
+            this._logger.logIncoming(msgLength, req, 1 /* RequestInitiator.OtherSide */, `receiveCancel`);
+        }
+        const callId = String(req);
+        if (this._cancelInvokedHandlers[callId]) {
+            this._cancelInvokedHandlers[callId]();
+        }
+    }
+    _receiveReply(msgLength, req, value) {
+        if (this._logger) {
+            this._logger.logIncoming(msgLength, req, 0 /* RequestInitiator.LocalSide */, `receiveReply:`, value);
+        }
+        const callId = String(req);
+        if (!this._pendingRPCReplies.hasOwnProperty(callId)) {
+            return;
+        }
+        const pendingReply = this._pendingRPCReplies[callId];
+        delete this._pendingRPCReplies[callId];
+        pendingReply.resolveOk(value);
+    }
+    _receiveReplyErr(msgLength, req, value) {
+        if (this._logger) {
+            this._logger.logIncoming(msgLength, req, 0 /* RequestInitiator.LocalSide */, `receiveReplyErr:`, value);
+        }
+        const callId = String(req);
+        if (!this._pendingRPCReplies.hasOwnProperty(callId)) {
+            return;
+        }
+        const pendingReply = this._pendingRPCReplies[callId];
+        delete this._pendingRPCReplies[callId];
+        let err = null;
+        if (value && value.$isError) {
+            err = new Error();
+            err.name = value.name;
+            err.message = value.message;
+            err.stack = value.stack;
+        }
+        pendingReply.resolveErr(err);
+    }
+    _invokeHandler(rpcId, methodName, args) {
+        try {
+            return Promise.resolve(this._doInvokeHandler(rpcId, methodName, args));
+        }
+        catch (err) {
+            return Promise.reject(err);
+        }
+    }
+    _doInvokeHandler(rpcId, methodName, args) {
+        const actor = this._locals[rpcId];
+        if (!actor) {
+            // @sri add logging
+            console.log('Unknown actor: ', { actor: this._locals[0], exists: this._locals.hasOwnProperty(rpcId), actors: Object.keys(this._locals), rpcId });
+            throw new Error('Unknown actor ' + (0, proxy_identifier_1.getStringIdentifierForProxy)(rpcId));
+        }
+        let method = actor[methodName];
+        if (typeof method !== 'function') {
+            throw new Error('Unknown method ' + methodName + ' on actor ' + (0, proxy_identifier_1.getStringIdentifierForProxy)(rpcId));
+        }
+        return method.apply(actor, args);
+    }
+    _remoteCall(destId, rpcId, methodName, args) {
+        if (this._isDisposed) {
+            return Promise.reject(errors.canceled());
+        }
+        let cancellationToken = null;
+        if (args.length > 0 && cancellation_1.CancellationToken.isCancellationToken(args[args.length - 1])) {
+            cancellationToken = args.pop();
+        }
+        if (cancellationToken && cancellationToken.isCancellationRequested) {
+            // No need to do anything...
+            return Promise.reject(errors.canceled());
+        }
+        const req = ++this._lastMessageId;
+        const callId = String(req);
+        const result = new utils_1.LazyPromise();
+        if (cancellationToken) {
+            cancellationToken.onCancellationRequested(() => {
+                const msg = MessageIO.serializeCancel(req);
+                if (this._logger) {
+                    this._logger.logOutgoing(msg.byteLength, req, 0 /* RequestInitiator.LocalSide */, `cancel`);
+                }
+                this._protocol.send(MessageIO.serializeCancel(req), destId);
+            });
+        }
+        this._pendingRPCReplies[callId] = result;
+        this._onWillSendRequest(req);
+        const msg = MessageIO.serializeRequest(req, rpcId, methodName, args, !!cancellationToken, this._uriReplacer);
+        if (this._logger) {
+            this._logger.logOutgoing(msg.byteLength, req, 0 /* RequestInitiator.LocalSide */, `request: ${(0, proxy_identifier_1.getStringIdentifierForProxy)(rpcId)}.${methodName}(`, args);
+        }
+        this._protocol.send(msg, destId);
+        return result;
+    }
+}
+exports.RPCProtocol = RPCProtocol;
+RPCProtocol.UNRESPONSIVE_TIME = 3 * 1000; // 3s
+class MessageBuffer {
+    constructor(buff, offset) {
+        this._buff = buff;
+        this._offset = offset;
+    }
+    static alloc(type, req, messageSize) {
+        let result = new MessageBuffer(buffer_1.VSBuffer.alloc(messageSize + 1 /* type */ + 4 /* req */), 0);
+        result.writeUInt8(type);
+        result.writeUInt32(req);
+        return result;
+    }
+    static read(buff, offset) {
+        return new MessageBuffer(buff, offset);
+    }
+    get buffer() {
+        return this._buff;
+    }
+    static sizeUInt8() {
+        return 1;
+    }
+    writeUInt8(n) {
+        this._buff.writeUInt8(n, this._offset);
+        this._offset += 1;
+    }
+    readUInt8() {
+        const n = this._buff.readUInt8(this._offset);
+        this._offset += 1;
+        return n;
+    }
+    writeUInt32(n) {
+        this._buff.writeUInt32BE(n, this._offset);
+        this._offset += 4;
+    }
+    readUInt32() {
+        const n = this._buff.readUInt32BE(this._offset);
+        this._offset += 4;
+        return n;
+    }
+    static sizeShortString(str) {
+        return 1 /* string length */ + str.byteLength /* actual string */;
+    }
+    writeShortString(str) {
+        this._buff.writeUInt8(str.byteLength, this._offset);
+        this._offset += 1;
+        this._buff.set(str, this._offset);
+        this._offset += str.byteLength;
+    }
+    readShortString() {
+        const strByteLength = this._buff.readUInt8(this._offset);
+        this._offset += 1;
+        const strBuff = this._buff.slice(this._offset, this._offset + strByteLength);
+        const str = strBuff.toString();
+        this._offset += strByteLength;
+        return str;
+    }
+    static sizeLongString(str) {
+        return 4 /* string length */ + str.byteLength /* actual string */;
+    }
+    writeLongString(str) {
+        this._buff.writeUInt32BE(str.byteLength, this._offset);
+        this._offset += 4;
+        this._buff.set(str, this._offset);
+        this._offset += str.byteLength;
+    }
+    readLongString() {
+        const strByteLength = this._buff.readUInt32BE(this._offset);
+        this._offset += 4;
+        const strBuff = this._buff.slice(this._offset, this._offset + strByteLength);
+        const str = strBuff.toString();
+        this._offset += strByteLength;
+        return str;
+    }
+    static sizeBuffer(buff) {
+        return 4 /* buffer length */ + buff.byteLength /* actual buffer */;
+    }
+    writeBuffer(buff) {
+        this._buff.writeUInt32BE(buff.byteLength, this._offset);
+        this._offset += 4;
+        this._buff.set(buff, this._offset);
+        this._offset += buff.byteLength;
+    }
+    readBuffer() {
+        const buffLength = this._buff.readUInt32BE(this._offset);
+        this._offset += 4;
+        const buff = this._buff.slice(this._offset, this._offset + buffLength);
+        this._offset += buffLength;
+        return buff.buffer;
+    }
+    static sizeVSBuffer(buff) {
+        return 4 /* buffer length */ + buff.byteLength /* actual buffer */;
+    }
+    writeVSBuffer(buff) {
+        this._buff.writeUInt32BE(buff.byteLength, this._offset);
+        this._offset += 4;
+        this._buff.set(buff, this._offset);
+        this._offset += buff.byteLength;
+    }
+    readVSBuffer() {
+        const buffLength = this._buff.readUInt32BE(this._offset);
+        this._offset += 4;
+        const buff = this._buff.slice(this._offset, this._offset + buffLength);
+        this._offset += buffLength;
+        return buff;
+    }
+    static sizeMixedArray(arr, arrType) {
+        let size = 0;
+        size += 1; // arr length
+        for (let i = 0, len = arr.length; i < len; i++) {
+            const el = arr[i];
+            const elType = arrType[i];
+            size += 1; // arg type
+            if (elType === 1 /* ArgType.String */) {
+                size += this.sizeLongString(el);
+            }
+            else if (elType === 2 /* ArgType.Buffer */) {
+                size += this.sizeBuffer(el);
+            }
+            else {
+                size += this.sizeVSBuffer(el);
+            }
+        }
+        return size;
+    }
+    writeMixedArray(arr, arrType) {
+        this._buff.writeUInt8(arr.length, this._offset);
+        this._offset += 1;
+        for (let i = 0, len = arr.length; i < len; i++) {
+            const el = arr[i];
+            const elType = arrType[i];
+            if (elType === 1 /* ArgType.String */) {
+                this.writeUInt8(1 /* ArgType.String */);
+                this.writeLongString(el);
+            }
+            else if (elType === 2 /* ArgType.Buffer */) {
+                this.writeUInt8(2 /* ArgType.Buffer */);
+                this.writeVSBuffer(el);
+            }
+            else {
+                this.writeUInt8(3 /* ArgType.VSBuffer */);
+                this.writeVSBuffer(el);
+            }
+        }
+    }
+    readMixedArray() {
+        const arrLen = this._buff.readUInt8(this._offset);
+        this._offset += 1;
+        let arr = new Array(arrLen);
+        for (let i = 0; i < arrLen; i++) {
+            const argType = this.readUInt8();
+            switch (argType) {
+                case 1 /* ArgType.String */:
+                    arr[i] = this.readLongString();
+                    break;
+                case 2 /* ArgType.Buffer */:
+                    arr[i] = this.readBuffer();
+                    break;
+                case 3 /* ArgType.VSBuffer */:
+                    arr[i] = this.readVSBuffer();
+                    break;
+            }
+        }
+        return arr;
+    }
+}
+exports.MessageBuffer = MessageBuffer;
+class MessageIO {
+    static _arrayContainsBuffer(arr) {
+        for (let i = 0, len = arr.length; i < len; i++) {
+            if (Buffer.isBuffer(arr[i])) {
+                return true;
+            }
+            if (arr[i] instanceof buffer_1.VSBuffer) {
+                return true;
+            }
+        }
+        return false;
+    }
+    static serializeRequest(req, rpcId, method, args, usesCancellationToken, replacer) {
+        if (this._arrayContainsBuffer(args)) {
+            let massagedArgs = [];
+            let massagedArgsType = [];
+            for (let i = 0, len = args.length; i < len; i++) {
+                const arg = args[i];
+                if (Buffer.isBuffer(arg)) {
+                    massagedArgs[i] = buffer_1.VSBuffer.wrap(arg);
+                    massagedArgsType[i] = 2 /* ArgType.Buffer */;
+                }
+                else if (arg instanceof buffer_1.VSBuffer) {
+                    massagedArgs[i] = arg;
+                    massagedArgsType[i] = 3 /* ArgType.VSBuffer */;
+                }
+                else {
+                    massagedArgs[i] = buffer_1.VSBuffer.fromString(safeStringify(arg, replacer));
+                    massagedArgsType[i] = 1 /* ArgType.String */;
+                }
+            }
+            return this._requestMixedArgs(req, rpcId, method, massagedArgs, massagedArgsType, usesCancellationToken);
+        }
+        return this._requestJSONArgs(req, rpcId, method, safeStringify(args, replacer), usesCancellationToken);
+    }
+    static _requestJSONArgs(req, rpcId, method, args, usesCancellationToken) {
+        const methodBuff = buffer_1.VSBuffer.fromString(method);
+        const argsBuff = buffer_1.VSBuffer.fromString(args);
+        let len = 0;
+        len += MessageBuffer.sizeUInt8();
+        len += MessageBuffer.sizeShortString(methodBuff);
+        len += MessageBuffer.sizeLongString(argsBuff);
+        let result = MessageBuffer.alloc(usesCancellationToken ? 2 /* MessageType.RequestJSONArgsWithCancellation */ : 1 /* MessageType.RequestJSONArgs */, req, len);
+        result.writeUInt8(rpcId);
+        result.writeShortString(methodBuff);
+        result.writeLongString(argsBuff);
+        return result.buffer;
+    }
+    static deserializeRequestJSONArgs(buff) {
+        const rpcId = buff.readUInt8();
+        const method = buff.readShortString();
+        const args = buff.readLongString();
+        return {
+            rpcId: rpcId,
+            method: method,
+            args: JSON.parse(args)
+        };
+    }
+    static _requestMixedArgs(req, rpcId, method, args, argsType, usesCancellationToken) {
+        const methodBuff = buffer_1.VSBuffer.fromString(method);
+        let len = 0;
+        len += MessageBuffer.sizeUInt8();
+        len += MessageBuffer.sizeShortString(methodBuff);
+        len += MessageBuffer.sizeMixedArray(args, argsType);
+        let result = MessageBuffer.alloc(usesCancellationToken ? 4 /* MessageType.RequestMixedArgsWithCancellation */ : 3 /* MessageType.RequestMixedArgs */, req, len);
+        result.writeUInt8(rpcId);
+        result.writeShortString(methodBuff);
+        result.writeMixedArray(args, argsType);
+        return result.buffer;
+    }
+    static deserializeRequestMixedArgs(buff) {
+        const rpcId = buff.readUInt8();
+        const method = buff.readShortString();
+        const rawargs = buff.readMixedArray();
+        const args = new Array(rawargs.length);
+        for (let i = 0, len = rawargs.length; i < len; i++) {
+            const rawarg = rawargs[i];
+            if (typeof rawarg === 'string') {
+                args[i] = JSON.parse(rawarg);
+            }
+            else {
+                args[i] = rawarg;
+            }
+        }
+        return {
+            rpcId: rpcId,
+            method: method,
+            args: args
+        };
+    }
+    static serializeAcknowledged(req) {
+        return MessageBuffer.alloc(5 /* MessageType.Acknowledged */, req, 0).buffer;
+    }
+    static serializeCancel(req) {
+        return MessageBuffer.alloc(6 /* MessageType.Cancel */, req, 0).buffer;
+    }
+    static serializeReplyOK(req, res, replacer) {
+        if (typeof res === 'undefined') {
+            return this._serializeReplyOKEmpty(req);
+        }
+        if (Buffer.isBuffer(res)) {
+            return this._serializeReplyOKBuffer(req, res);
+        }
+        if (res instanceof buffer_1.VSBuffer) {
+            return this._serializeReplyOKVSBuffer(req, res);
+        }
+        return this._serializeReplyOKJSON(req, safeStringify(res, replacer));
+    }
+    static _serializeReplyOKEmpty(req) {
+        return MessageBuffer.alloc(7 /* MessageType.ReplyOKEmpty */, req, 0).buffer;
+    }
+    static _serializeReplyOKBuffer(req, res) {
+        const buff = buffer_1.VSBuffer.wrap(res);
+        let len = 0;
+        len += MessageBuffer.sizeBuffer(buff);
+        let result = MessageBuffer.alloc(8 /* MessageType.ReplyOKBuffer */, req, len);
+        result.writeBuffer(buff);
+        return result.buffer;
+    }
+    static _serializeReplyOKVSBuffer(req, res) {
+        let len = 0;
+        len += MessageBuffer.sizeVSBuffer(res);
+        let result = MessageBuffer.alloc(8 /* MessageType.ReplyOKVSBuffer */, req, len);
+        result.writeVSBuffer(res);
+        return result.buffer;
+    }
+    static deserializeReplyOKBuffer(buff) {
+        return buff.readBuffer();
+    }
+    static deserializeReplyOKVSBuffer(buff) {
+        return buff.readVSBuffer();
+    }
+    static _serializeReplyOKJSON(req, res) {
+        const resBuff = buffer_1.VSBuffer.fromString(res);
+        let len = 0;
+        len += MessageBuffer.sizeLongString(resBuff);
+        let result = MessageBuffer.alloc(9 /* MessageType.ReplyOKJSON */, req, len);
+        result.writeLongString(resBuff);
+        return result.buffer;
+    }
+    static deserializeReplyOKJSON(buff) {
+        const res = buff.readLongString();
+        return JSON.parse(res);
+    }
+    static serializeReplyErr(req, err) {
+        if (err instanceof Error) {
+            return this._serializeReplyErrEror(req, err);
+        }
+        return this._serializeReplyErrEmpty(req);
+    }
+    static _serializeReplyErrEror(req, _err) {
+        const errBuff = buffer_1.VSBuffer.fromString(safeStringify(errors.transformErrorForSerialization(_err), null));
+        let len = 0;
+        len += MessageBuffer.sizeLongString(errBuff);
+        let result = MessageBuffer.alloc(10 /* MessageType.ReplyErrError */, req, len);
+        result.writeLongString(errBuff);
+        return result.buffer;
+    }
+    static deserializeReplyErrError(buff) {
+        const err = buff.readLongString();
+        return JSON.parse(err);
+    }
+    static _serializeReplyErrEmpty(req) {
+        return MessageBuffer.alloc(11 /* MessageType.ReplyErrEmpty */, req, 0).buffer;
+    }
+}
+exports.MessageIO = MessageIO;
+var MessageType;
+(function (MessageType) {
+    MessageType[MessageType["RequestJSONArgs"] = 1] = "RequestJSONArgs";
+    MessageType[MessageType["RequestJSONArgsWithCancellation"] = 2] = "RequestJSONArgsWithCancellation";
+    MessageType[MessageType["RequestMixedArgs"] = 3] = "RequestMixedArgs";
+    MessageType[MessageType["RequestMixedArgsWithCancellation"] = 4] = "RequestMixedArgsWithCancellation";
+    MessageType[MessageType["Acknowledged"] = 5] = "Acknowledged";
+    MessageType[MessageType["Cancel"] = 6] = "Cancel";
+    MessageType[MessageType["ReplyOKEmpty"] = 7] = "ReplyOKEmpty";
+    MessageType[MessageType["ReplyOKBuffer"] = 8] = "ReplyOKBuffer";
+    MessageType[MessageType["ReplyOKVSBuffer"] = 8] = "ReplyOKVSBuffer";
+    MessageType[MessageType["ReplyOKJSON"] = 9] = "ReplyOKJSON";
+    MessageType[MessageType["ReplyErrError"] = 10] = "ReplyErrError";
+    MessageType[MessageType["ReplyErrEmpty"] = 11] = "ReplyErrEmpty";
+})(MessageType = exports.MessageType || (exports.MessageType = {}));
+var ArgType;
+(function (ArgType) {
+    ArgType[ArgType["String"] = 1] = "String";
+    ArgType[ArgType["Buffer"] = 2] = "Buffer";
+    ArgType[ArgType["VSBuffer"] = 3] = "VSBuffer";
+})(ArgType = exports.ArgType || (exports.ArgType = {}));
+//# sourceMappingURL=rpc-protocol.js.map