@codingame/monaco-vscode-api 5.2.0 → 6.0.0

package/vscode/src/vs/base/parts/ipc/common/ipc.js

@@ -7,31 +7,48 @@ import { memoize } from '../../../common/decorators.js';
 import { CancellationError } from '../../../common/errors.js';
 import { Relay, Emitter, Event } from '../../../common/event.js';
 import { toDisposable, dispose, combinedDisposable } from '../../../common/lifecycle.js';
+import '../../../common/charCode.js';
+import '../../../common/marshallingIds.js';
 import '../../../common/path.js';
 import '../../../common/platform.js';
 import '../../../common/strings.js';
+var RequestType;
+( (function(RequestType) {
+    RequestType[RequestType["Promise"] = 100] = "Promise";
+    RequestType[RequestType["PromiseCancel"] = 101] = "PromiseCancel";
+    RequestType[RequestType["EventListen"] = 102] = "EventListen";
+    RequestType[RequestType["EventDispose"] = 103] = "EventDispose";
+})(RequestType || (RequestType = {})));
 function requestTypeToStr(type) {
     switch (type) {
-        case 100 :
+        case RequestType.Promise:
             return 'req';
-        case 101 :
+        case RequestType.PromiseCancel:
             return 'cancel';
-        case 102 :
+        case RequestType.EventListen:
             return 'subscribe';
-        case 103 :
+        case RequestType.EventDispose:
             return 'unsubscribe';
     }
 }
+var ResponseType;
+( (function(ResponseType) {
+    ResponseType[ResponseType["Initialize"] = 200] = "Initialize";
+    ResponseType[ResponseType["PromiseSuccess"] = 201] = "PromiseSuccess";
+    ResponseType[ResponseType["PromiseError"] = 202] = "PromiseError";
+    ResponseType[ResponseType["PromiseErrorObj"] = 203] = "PromiseErrorObj";
+    ResponseType[ResponseType["EventFire"] = 204] = "EventFire";
+})(ResponseType || (ResponseType = {})));
 function responseTypeToStr(type) {
     switch (type) {
-        case 200 :
+        case ResponseType.Initialize:
             return `init`;
-        case 201 :
+        case ResponseType.PromiseSuccess:
             return `reply:`;
-        case 202 :
-        case 203 :
+        case ResponseType.PromiseError:
+        case ResponseType.PromiseErrorObj:
             return `replyErr:`;
-        case 204 :
+        case ResponseType.EventFire:
             return `event:`;
     }
 }
@@ -185,7 +202,7 @@ class ChannelServer {
         this.activeRequests = ( new Map());
         this.pendingRequests = ( new Map());
         this.protocolListener = this.protocol.onMessage(msg => this.onRawMessage(msg));
-        this.sendResponse({ type: 200  });
+        this.sendResponse({ type: ResponseType.Initialize });
     }
     registerChannel(channelName, channel) {
         this.channels.set(channelName, channel);
@@ -193,17 +210,17 @@ class ChannelServer {
     }
     sendResponse(response) {
         switch (response.type) {
-            case 200 : {
+            case ResponseType.Initialize: {
                 const msgLength = this.send([response.type]);
-                this.logger?.logOutgoing(msgLength, 0, 1 , responseTypeToStr(response.type));
+                this.logger?.logOutgoing(msgLength, 0, RequestInitiator.OtherSide, responseTypeToStr(response.type));
                 return;
             }
-            case 201 :
-            case 202 :
-            case 204 :
-            case 203 : {
+            case ResponseType.PromiseSuccess:
+            case ResponseType.PromiseError:
+            case ResponseType.EventFire:
+            case ResponseType.PromiseErrorObj: {
                 const msgLength = this.send([response.type, response.id], response.data);
-                this.logger?.logOutgoing(msgLength, response.id, 1 , responseTypeToStr(response.type), response.data);
+                this.logger?.logOutgoing(msgLength, response.id, RequestInitiator.OtherSide, responseTypeToStr(response.type), response.data);
                 return;
             }
         }
@@ -229,17 +246,17 @@ class ChannelServer {
         const body = deserialize(reader);
         const type = header[0];
         switch (type) {
-            case 100 :
-                this.logger?.logIncoming(message.byteLength, header[1], 1 , `${requestTypeToStr(type)}: ${header[2]}.${header[3]}`, body);
+            case RequestType.Promise:
+                this.logger?.logIncoming(message.byteLength, header[1], RequestInitiator.OtherSide, `${requestTypeToStr(type)}: ${header[2]}.${header[3]}`, body);
                 return this.onPromise({ type, id: header[1], channelName: header[2], name: header[3], arg: body });
-            case 102 :
-                this.logger?.logIncoming(message.byteLength, header[1], 1 , `${requestTypeToStr(type)}: ${header[2]}.${header[3]}`, body);
+            case RequestType.EventListen:
+                this.logger?.logIncoming(message.byteLength, header[1], RequestInitiator.OtherSide, `${requestTypeToStr(type)}: ${header[2]}.${header[3]}`, body);
                 return this.onEventListen({ type, id: header[1], channelName: header[2], name: header[3], arg: body });
-            case 101 :
-                this.logger?.logIncoming(message.byteLength, header[1], 1 , `${requestTypeToStr(type)}`);
+            case RequestType.PromiseCancel:
+                this.logger?.logIncoming(message.byteLength, header[1], RequestInitiator.OtherSide, `${requestTypeToStr(type)}`);
                 return this.disposeActiveRequest({ type, id: header[1] });
-            case 103 :
-                this.logger?.logIncoming(message.byteLength, header[1], 1 , `${requestTypeToStr(type)}`);
+            case RequestType.EventDispose:
+                this.logger?.logIncoming(message.byteLength, header[1], RequestInitiator.OtherSide, `${requestTypeToStr(type)}`);
                 return this.disposeActiveRequest({ type, id: header[1] });
         }
     }
@@ -259,7 +276,7 @@ class ChannelServer {
         }
         const id = request.id;
         promise.then(data => {
-            this.sendResponse({ id, data, type: 201  });
+            this.sendResponse({ id, data, type: ResponseType.PromiseSuccess });
         }, err => {
             if (err instanceof Error) {
                 this.sendResponse({
@@ -267,11 +284,11 @@ class ChannelServer {
                         message: err.message,
                         name: err.name,
                         stack: err.stack ? (err.stack.split ? err.stack.split('\n') : err.stack) : undefined
-                    }, type: 202
+                    }, type: ResponseType.PromiseError
                 });
             }
             else {
-                this.sendResponse({ id, data: err, type: 203  });
+                this.sendResponse({ id, data: err, type: ResponseType.PromiseErrorObj });
             }
         }).finally(() => {
             disposable.dispose();
@@ -288,7 +305,7 @@ class ChannelServer {
         }
         const id = request.id;
         const event = channel.listen(this.ctx, request.name, request.arg);
-        const disposable = event(data => this.sendResponse({ id, data, type: 204  }));
+        const disposable = event(data => this.sendResponse({ id, data, type: ResponseType.EventFire }));
         this.activeRequests.set(request.id, disposable);
     }
     disposeActiveRequest(request) {
@@ -306,11 +323,11 @@ class ChannelServer {
         }
         const timer = setTimeout(() => {
             console.error(`Unknown channel: ${request.channelName}`);
-            if (request.type === 100 ) {
+            if (request.type === RequestType.Promise) {
                 this.sendResponse({
                     id: request.id,
                     data: { name: 'Unknown channel', message: `Channel name '${request.channelName}' timed out after ${this.timeoutDelay}ms`, stack: undefined },
-                    type: 202
+                    type: ResponseType.PromiseError
                 });
             }
         }, this.timeoutDelay);
@@ -322,10 +339,10 @@ class ChannelServer {
             for (const request of requests) {
                 clearTimeout(request.timeoutTimer);
                 switch (request.request.type) {
-                    case 100 :
+                    case RequestType.Promise:
                         this.onPromise(request.request);
                         break;
-                    case 102 :
+                    case RequestType.EventListen:
                         this.onEventListen(request.request);
                         break;
                 }
@@ -342,6 +359,11 @@ class ChannelServer {
         this.activeRequests.clear();
     }
 }
+var RequestInitiator;
+( (function(RequestInitiator) {
+    RequestInitiator[RequestInitiator["LocalSide"] = 0] = "LocalSide";
+    RequestInitiator[RequestInitiator["OtherSide"] = 1] = "OtherSide";
+})(RequestInitiator || (RequestInitiator = {})));
 class ChannelClient {
     constructor(protocol, logger = null) {
         this.protocol = protocol;
@@ -374,7 +396,7 @@ class ChannelClient {
     }
     requestPromise(channelName, name, arg, cancellationToken = CancellationToken.None) {
         const id = this.lastRequestId++;
-        const type = 100 ;
+        const type = RequestType.Promise;
         const request = { id, type, channelName, name, arg };
         if (cancellationToken.isCancellationRequested) {
             return Promise.reject(( new CancellationError()));
@@ -387,11 +409,11 @@ class ChannelClient {
             const doRequest = () => {
                 const handler = response => {
                     switch (response.type) {
-                        case 201 :
+                        case ResponseType.PromiseSuccess:
                             this.handlers.delete(id);
                             c(response.data);
                             break;
-                        case 202 : {
+                        case ResponseType.PromiseError: {
                             this.handlers.delete(id);
                             const error = ( new Error(response.data.message));
                             error.stack = Array.isArray(response.data.stack) ? response.data.stack.join('\n') : response.data.stack;
@@ -399,7 +421,7 @@ class ChannelClient {
                             e(error);
                             break;
                         }
-                        case 203 :
+                        case ResponseType.PromiseErrorObj:
                             this.handlers.delete(id);
                             e(response.data);
                             break;
@@ -425,7 +447,7 @@ class ChannelClient {
                     uninitializedPromise = null;
                 }
                 else {
-                    this.sendRequest({ id, type: 101  });
+                    this.sendRequest({ id, type: RequestType.PromiseCancel });
                 }
                 e(( new CancellationError()));
             };
@@ -440,7 +462,7 @@ class ChannelClient {
     }
     requestEvent(channelName, name, arg) {
         const id = this.lastRequestId++;
-        const type = 102 ;
+        const type = RequestType.EventListen;
         const request = { id, type, channelName, name, arg };
         let uninitializedPromise = null;
         const emitter = ( new Emitter({
@@ -459,7 +481,7 @@ class ChannelClient {
                 }
                 else {
                     this.activeRequests.delete(emitter);
-                    this.sendRequest({ id, type: 103  });
+                    this.sendRequest({ id, type: RequestType.EventDispose });
                 }
             }
         }));
@@ -469,16 +491,16 @@ class ChannelClient {
     }
     sendRequest(request) {
         switch (request.type) {
-            case 100 :
-            case 102 : {
+            case RequestType.Promise:
+            case RequestType.EventListen: {
                 const msgLength = this.send([request.type, request.id, request.channelName, request.name], request.arg);
-                this.logger?.logOutgoing(msgLength, request.id, 0 , `${requestTypeToStr(request.type)}: ${request.channelName}.${request.name}`, request.arg);
+                this.logger?.logOutgoing(msgLength, request.id, RequestInitiator.LocalSide, `${requestTypeToStr(request.type)}: ${request.channelName}.${request.name}`, request.arg);
                 return;
             }
-            case 101 :
-            case 103 : {
+            case RequestType.PromiseCancel:
+            case RequestType.EventDispose: {
                 const msgLength = this.send([request.type, request.id]);
-                this.logger?.logOutgoing(msgLength, request.id, 0 , requestTypeToStr(request.type));
+                this.logger?.logOutgoing(msgLength, request.id, RequestInitiator.LocalSide, requestTypeToStr(request.type));
                 return;
             }
         }
@@ -504,19 +526,19 @@ class ChannelClient {
         const body = deserialize(reader);
         const type = header[0];
         switch (type) {
-            case 200 :
-                this.logger?.logIncoming(message.byteLength, 0, 0 , responseTypeToStr(type));
+            case ResponseType.Initialize:
+                this.logger?.logIncoming(message.byteLength, 0, RequestInitiator.LocalSide, responseTypeToStr(type));
                 return this.onResponse({ type: header[0] });
-            case 201 :
-            case 202 :
-            case 204 :
-            case 203 :
-                this.logger?.logIncoming(message.byteLength, header[1], 0 , responseTypeToStr(type), body);
+            case ResponseType.PromiseSuccess:
+            case ResponseType.PromiseError:
+            case ResponseType.EventFire:
+            case ResponseType.PromiseErrorObj:
+                this.logger?.logIncoming(message.byteLength, header[1], RequestInitiator.LocalSide, responseTypeToStr(type), body);
                 return this.onResponse({ type: header[0], id: header[1], data: body });
         }
     }
     onResponse(response) {
-        if (response.type === 200 ) {
+        if (response.type === ResponseType.Initialize) {
             this.state = State.Idle;
             this._onDidInitialize.fire();
             return;
@@ -579,4 +601,4 @@ function getDelayedChannel(promise) {
         }
     };
 }
-export { BufferReader, BufferWriter, ChannelClient, ChannelServer, IPCClient, deserialize, getDelayedChannel, serialize };
+export { BufferReader, BufferWriter, ChannelClient, ChannelServer, IPCClient, RequestInitiator, deserialize, getDelayedChannel, serialize };

package/vscode/src/vs/base/parts/ipc/common/ipc.net.js

@@ -2,6 +2,42 @@ import { VSBuffer } from '../../../common/buffer.js';
 import { Emitter } from '../../../common/event.js';
 import { Disposable, DisposableStore } from '../../../common/lifecycle.js';
 import { IPCClient } from './ipc.js';
+var SocketDiagnosticsEventType;
+( (function(SocketDiagnosticsEventType) {
+    SocketDiagnosticsEventType["Created"] = "created";
+    SocketDiagnosticsEventType["Read"] = "read";
+    SocketDiagnosticsEventType["Write"] = "write";
+    SocketDiagnosticsEventType["Open"] = "open";
+    SocketDiagnosticsEventType["Error"] = "error";
+    SocketDiagnosticsEventType["Close"] = "close";
+    SocketDiagnosticsEventType["BrowserWebSocketBlobReceived"] = "browserWebSocketBlobReceived";
+    SocketDiagnosticsEventType["NodeEndReceived"] = "nodeEndReceived";
+    SocketDiagnosticsEventType["NodeEndSent"] = "nodeEndSent";
+    SocketDiagnosticsEventType["NodeDrainBegin"] = "nodeDrainBegin";
+    SocketDiagnosticsEventType["NodeDrainEnd"] = "nodeDrainEnd";
+    SocketDiagnosticsEventType["zlibInflateError"] = "zlibInflateError";
+    SocketDiagnosticsEventType["zlibInflateData"] = "zlibInflateData";
+    SocketDiagnosticsEventType["zlibInflateInitialWrite"] = "zlibInflateInitialWrite";
+    SocketDiagnosticsEventType["zlibInflateInitialFlushFired"] = "zlibInflateInitialFlushFired";
+    SocketDiagnosticsEventType["zlibInflateWrite"] = "zlibInflateWrite";
+    SocketDiagnosticsEventType["zlibInflateFlushFired"] = "zlibInflateFlushFired";
+    SocketDiagnosticsEventType["zlibDeflateError"] = "zlibDeflateError";
+    SocketDiagnosticsEventType["zlibDeflateData"] = "zlibDeflateData";
+    SocketDiagnosticsEventType["zlibDeflateWrite"] = "zlibDeflateWrite";
+    SocketDiagnosticsEventType["zlibDeflateFlushFired"] = "zlibDeflateFlushFired";
+    SocketDiagnosticsEventType["WebSocketNodeSocketWrite"] = "webSocketNodeSocketWrite";
+    SocketDiagnosticsEventType["WebSocketNodeSocketPeekedHeader"] = "webSocketNodeSocketPeekedHeader";
+    SocketDiagnosticsEventType["WebSocketNodeSocketReadHeader"] = "webSocketNodeSocketReadHeader";
+    SocketDiagnosticsEventType["WebSocketNodeSocketReadData"] = "webSocketNodeSocketReadData";
+    SocketDiagnosticsEventType["WebSocketNodeSocketUnmaskedData"] = "webSocketNodeSocketUnmaskedData";
+    SocketDiagnosticsEventType["WebSocketNodeSocketDrainBegin"] = "webSocketNodeSocketDrainBegin";
+    SocketDiagnosticsEventType["WebSocketNodeSocketDrainEnd"] = "webSocketNodeSocketDrainEnd";
+    SocketDiagnosticsEventType["ProtocolHeaderRead"] = "protocolHeaderRead";
+    SocketDiagnosticsEventType["ProtocolMessageRead"] = "protocolMessageRead";
+    SocketDiagnosticsEventType["ProtocolHeaderWrite"] = "protocolHeaderWrite";
+    SocketDiagnosticsEventType["ProtocolMessageWrite"] = "protocolMessageWrite";
+    SocketDiagnosticsEventType["ProtocolWrite"] = "protocolWrite";
+})(SocketDiagnosticsEventType || (SocketDiagnosticsEventType = {})));
 var SocketDiagnostics;
 ( (function(SocketDiagnostics) {
     SocketDiagnostics.enableDiagnostics = false;
@@ -31,6 +67,11 @@ var SocketDiagnostics;
     }
     SocketDiagnostics.traceSocketEvent = traceSocketEvent;
 })(SocketDiagnostics || (SocketDiagnostics = {})));
+var SocketCloseEventType;
+( (function(SocketCloseEventType) {
+    SocketCloseEventType[SocketCloseEventType["NodeSocketCloseEvent"] = 0] = "NodeSocketCloseEvent";
+    SocketCloseEventType[SocketCloseEventType["WebSocketCloseEvent"] = 1] = "WebSocketCloseEvent";
+})(SocketCloseEventType || (SocketCloseEventType = {})));
 let emptyBuffer = null;
 function getEmptyBuffer() {
     if (!emptyBuffer) {
@@ -110,19 +151,40 @@ class ChunkStream {
         return result;
     }
 }
+var ProtocolMessageType;
+( (function(ProtocolMessageType) {
+    ProtocolMessageType[ProtocolMessageType["None"] = 0] = "None";
+    ProtocolMessageType[ProtocolMessageType["Regular"] = 1] = "Regular";
+    ProtocolMessageType[ProtocolMessageType["Control"] = 2] = "Control";
+    ProtocolMessageType[ProtocolMessageType["Ack"] = 3] = "Ack";
+    ProtocolMessageType[ProtocolMessageType["Disconnect"] = 5] = "Disconnect";
+    ProtocolMessageType[ProtocolMessageType["ReplayRequest"] = 6] = "ReplayRequest";
+    ProtocolMessageType[ProtocolMessageType["Pause"] = 7] = "Pause";
+    ProtocolMessageType[ProtocolMessageType["Resume"] = 8] = "Resume";
+    ProtocolMessageType[ProtocolMessageType["KeepAlive"] = 9] = "KeepAlive";
+})(ProtocolMessageType || (ProtocolMessageType = {})));
 function protocolMessageTypeToString(messageType) {
     switch (messageType) {
-        case 0 : return 'None';
-        case 1 : return 'Regular';
-        case 2 : return 'Control';
-        case 3 : return 'Ack';
-        case 5 : return 'Disconnect';
-        case 6 : return 'ReplayRequest';
-        case 7 : return 'PauseWriting';
-        case 8 : return 'ResumeWriting';
-        case 9 : return 'KeepAlive';
+        case ProtocolMessageType.None: return 'None';
+        case ProtocolMessageType.Regular: return 'Regular';
+        case ProtocolMessageType.Control: return 'Control';
+        case ProtocolMessageType.Ack: return 'Ack';
+        case ProtocolMessageType.Disconnect: return 'Disconnect';
+        case ProtocolMessageType.ReplayRequest: return 'ReplayRequest';
+        case ProtocolMessageType.Pause: return 'PauseWriting';
+        case ProtocolMessageType.Resume: return 'ResumeWriting';
+        case ProtocolMessageType.KeepAlive: return 'KeepAlive';
     }
 }
+var ProtocolConstants;
+( (function(ProtocolConstants) {
+    ProtocolConstants[ProtocolConstants["HeaderLength"] = 13] = "HeaderLength";
+    ProtocolConstants[ProtocolConstants["AcknowledgeTime"] = 2000] = "AcknowledgeTime";
+    ProtocolConstants[ProtocolConstants["TimeoutTime"] = 20000] = "TimeoutTime";
+    ProtocolConstants[ProtocolConstants["ReconnectionGraceTime"] = 10800000] = "ReconnectionGraceTime";
+    ProtocolConstants[ProtocolConstants["ReconnectionShortGraceTime"] = 300000] = "ReconnectionShortGraceTime";
+    ProtocolConstants[ProtocolConstants["KeepAliveSendTime"] = 5000] = "KeepAliveSendTime";
+})(ProtocolConstants || (ProtocolConstants = {})));
 class ProtocolMessage {
     constructor(type, id, ack, data) {
         this.type = type;
@@ -142,8 +204,8 @@ class ProtocolReader extends Disposable {
         this.onMessage = this._onMessage.event;
         this._state = {
             readHead: true,
-            readLen: 13 ,
-            messageType: 0 ,
+            readLen: ProtocolConstants.HeaderLength,
+            messageType: ProtocolMessageType.None,
             id: 0,
             ack: 0
         };
@@ -167,18 +229,18 @@ class ProtocolReader extends Disposable {
                 this._state.messageType = buff.readUInt8(0);
                 this._state.id = buff.readUInt32BE(1);
                 this._state.ack = buff.readUInt32BE(5);
-                this._socket.traceSocketEvent("protocolHeaderRead" , { messageType: protocolMessageTypeToString(this._state.messageType), id: this._state.id, ack: this._state.ack, messageSize: this._state.readLen });
+                this._socket.traceSocketEvent(SocketDiagnosticsEventType.ProtocolHeaderRead, { messageType: protocolMessageTypeToString(this._state.messageType), id: this._state.id, ack: this._state.ack, messageSize: this._state.readLen });
             }
             else {
                 const messageType = this._state.messageType;
                 const id = this._state.id;
                 const ack = this._state.ack;
                 this._state.readHead = true;
-                this._state.readLen = 13 ;
-                this._state.messageType = 0 ;
+                this._state.readLen = ProtocolConstants.HeaderLength;
+                this._state.messageType = ProtocolMessageType.None;
                 this._state.id = 0;
                 this._state.ack = 0;
-                this._socket.traceSocketEvent("protocolMessageRead" , buff);
+                this._socket.traceSocketEvent(SocketDiagnosticsEventType.ProtocolMessageRead, buff);
                 this._onMessage.fire(( new ProtocolMessage(messageType, id, ack, buff)));
                 if (this._isDisposed) {
                     break;
@@ -232,13 +294,13 @@ class ProtocolWriter {
         }
         msg.writtenTime = Date.now();
         this.lastWriteTime = Date.now();
-        const header = VSBuffer.alloc(13 );
+        const header = VSBuffer.alloc(ProtocolConstants.HeaderLength);
         header.writeUInt8(msg.type, 0);
         header.writeUInt32BE(msg.id, 1);
         header.writeUInt32BE(msg.ack, 5);
         header.writeUInt32BE(msg.data.byteLength, 9);
-        this._socket.traceSocketEvent("protocolHeaderWrite" , { messageType: protocolMessageTypeToString(msg.type), id: msg.id, ack: msg.ack, messageSize: msg.data.byteLength });
-        this._socket.traceSocketEvent("protocolMessageWrite" , msg.data);
+        this._socket.traceSocketEvent(SocketDiagnosticsEventType.ProtocolHeaderWrite, { messageType: protocolMessageTypeToString(msg.type), id: msg.id, ack: msg.ack, messageSize: msg.data.byteLength });
+        this._socket.traceSocketEvent(SocketDiagnosticsEventType.ProtocolMessageWrite, msg.data);
         this._writeSoon(header, msg.data);
     }
     _bufferAdd(head, body) {
@@ -275,7 +337,7 @@ class ProtocolWriter {
             return;
         }
         const data = this._bufferTake();
-        this._socket.traceSocketEvent("protocolWrite" , { byteLength: data.byteLength });
+        this._socket.traceSocketEvent(SocketDiagnosticsEventType.ProtocolWrite, { byteLength: data.byteLength });
         this._socket.write(data);
     }
 }
@@ -290,7 +352,7 @@ class Protocol extends Disposable {
         this._socketWriter = this._register(( new ProtocolWriter(this._socket)));
         this._socketReader = this._register(( new ProtocolReader(this._socket)));
         this._register(this._socketReader.onMessage((msg) => {
-            if (msg.type === 1 ) {
+            if (msg.type === ProtocolMessageType.Regular) {
                 this._onMessage.fire(msg.data);
             }
         }));
@@ -305,7 +367,7 @@ class Protocol extends Disposable {
     sendDisconnect() {
     }
     send(buffer) {
-        this._socketWriter.write(( new ProtocolMessage(1 , 0, 0, buffer)));
+        this._socketWriter.write(( new ProtocolMessage(ProtocolMessageType.Regular, 0, 0, buffer)));
     }
 }
 class Client extends IPCClient {
@@ -503,7 +565,7 @@ class PersistentProtocol {
         if (this._shouldSendKeepAlive) {
             this._keepAliveInterval = setInterval(() => {
                 this._sendKeepAlive();
-            }, 5000 );
+            }, ProtocolConstants.KeepAliveSendTime);
         }
         else {
             this._keepAliveInterval = null;
@@ -528,16 +590,16 @@ class PersistentProtocol {
         return this._socketWriter.drain();
     }
     sendDisconnect() {
-        const msg = ( new ProtocolMessage(5 , 0, 0, getEmptyBuffer()));
+        const msg = ( new ProtocolMessage(ProtocolMessageType.Disconnect, 0, 0, getEmptyBuffer()));
         this._socketWriter.write(msg);
         this._socketWriter.flush();
     }
     sendPause() {
-        const msg = ( new ProtocolMessage(7 , 0, 0, getEmptyBuffer()));
+        const msg = ( new ProtocolMessage(ProtocolMessageType.Pause, 0, 0, getEmptyBuffer()));
         this._socketWriter.write(msg);
     }
     sendResume() {
-        const msg = ( new ProtocolMessage(8 , 0, 0, getEmptyBuffer()));
+        const msg = ( new ProtocolMessage(ProtocolMessageType.Resume, 0, 0, getEmptyBuffer()));
         this._socketWriter.write(msg);
     }
     pauseSocketWriting() {
@@ -569,7 +631,7 @@ class PersistentProtocol {
     endAcceptReconnection() {
         this._isReconnecting = false;
         this._incomingAckId = this._incomingMsgId;
-        const msg = ( new ProtocolMessage(3 , 0, this._incomingAckId, getEmptyBuffer()));
+        const msg = ( new ProtocolMessage(ProtocolMessageType.Ack, 0, this._incomingAckId, getEmptyBuffer()));
         this._socketWriter.write(msg);
         const toSend = this._outgoingUnackMsg.toArray();
         for (let i = 0, len = toSend.length; i < len; i++) {
@@ -594,16 +656,16 @@ class PersistentProtocol {
             } while (true);
         }
         switch (msg.type) {
-            case 0 : {
+            case ProtocolMessageType.None: {
                 break;
             }
-            case 1 : {
+            case ProtocolMessageType.Regular: {
                 if (msg.id > this._incomingMsgId) {
                     if (msg.id !== this._incomingMsgId + 1) {
                         const now = Date.now();
                         if (now - this._lastReplayRequestTime > 10000) {
                             this._lastReplayRequestTime = now;
-                            this._socketWriter.write(( new ProtocolMessage(6 , 0, 0, getEmptyBuffer())));
+                            this._socketWriter.write(( new ProtocolMessage(ProtocolMessageType.ReplayRequest, 0, 0, getEmptyBuffer())));
                         }
                     }
                     else {
@@ -615,18 +677,18 @@ class PersistentProtocol {
                 }
                 break;
             }
-            case 2 : {
+            case ProtocolMessageType.Control: {
                 this._onControlMessage.fire(msg.data);
                 break;
             }
-            case 3 : {
+            case ProtocolMessageType.Ack: {
                 break;
             }
-            case 5 : {
+            case ProtocolMessageType.Disconnect: {
                 this._onDidDispose.fire();
                 break;
             }
-            case 6 : {
+            case ProtocolMessageType.ReplayRequest: {
                 const toSend = this._outgoingUnackMsg.toArray();
                 for (let i = 0, len = toSend.length; i < len; i++) {
                     this._socketWriter.write(toSend[i]);
@@ -634,11 +696,11 @@ class PersistentProtocol {
                 this._recvAckCheck();
                 break;
             }
-            case 7 : {
+            case ProtocolMessageType.Pause: {
                 this._socketWriter.pause();
                 break;
             }
-            case 8 : {
+            case ProtocolMessageType.Resume: {
                 this._socketWriter.resume();
                 break;
             }
@@ -653,7 +715,7 @@ class PersistentProtocol {
     send(buffer) {
         const myId = ++this._outgoingMsgId;
         this._incomingAckId = this._incomingMsgId;
-        const msg = ( new ProtocolMessage(1 , myId, this._incomingAckId, buffer));
+        const msg = ( new ProtocolMessage(ProtocolMessageType.Regular, myId, this._incomingAckId, buffer));
         this._outgoingUnackMsg.push(msg);
         if (!this._isReconnecting) {
             this._socketWriter.write(msg);
@@ -661,7 +723,7 @@ class PersistentProtocol {
         }
     }
     sendControl(buffer) {
-        const msg = ( new ProtocolMessage(2 , 0, 0, buffer));
+        const msg = ( new ProtocolMessage(ProtocolMessageType.Control, 0, 0, buffer));
         this._socketWriter.write(msg);
     }
     _sendAckCheck() {
@@ -672,14 +734,14 @@ class PersistentProtocol {
             return;
         }
         const timeSinceLastIncomingMsg = Date.now() - this._incomingMsgLastTime;
-        if (timeSinceLastIncomingMsg >= 2000 ) {
+        if (timeSinceLastIncomingMsg >= ProtocolConstants.AcknowledgeTime) {
             this._sendAck();
             return;
         }
         this._incomingAckTimeout = setTimeout(() => {
             this._incomingAckTimeout = null;
             this._sendAckCheck();
-        }, 2000  - timeSinceLastIncomingMsg + 5);
+        }, ProtocolConstants.AcknowledgeTime - timeSinceLastIncomingMsg + 5);
     }
     _recvAckCheck() {
         if (this._outgoingMsgId <= this._outgoingAckId) {
@@ -695,9 +757,9 @@ class PersistentProtocol {
         const timeSinceOldestUnacknowledgedMsg = Date.now() - oldestUnacknowledgedMsg.writtenTime;
         const timeSinceLastReceivedSomeData = Date.now() - this._socketReader.lastReadTime;
         const timeSinceLastTimeout = Date.now() - this._lastSocketTimeoutTime;
-        if (timeSinceOldestUnacknowledgedMsg >= 20000
-            && timeSinceLastReceivedSomeData >= 20000
-            && timeSinceLastTimeout >= 20000 ) {
+        if (timeSinceOldestUnacknowledgedMsg >= ProtocolConstants.TimeoutTime
+            && timeSinceLastReceivedSomeData >= ProtocolConstants.TimeoutTime
+            && timeSinceLastTimeout >= ProtocolConstants.TimeoutTime) {
             if (!this._loadEstimator.hasHighLoad()) {
                 this._lastSocketTimeoutTime = Date.now();
                 this._onSocketTimeout.fire({
@@ -708,7 +770,7 @@ class PersistentProtocol {
                 return;
             }
         }
-        const minimumTimeUntilTimeout = Math.max(20000  - timeSinceOldestUnacknowledgedMsg, 20000  - timeSinceLastReceivedSomeData, 20000  - timeSinceLastTimeout, 500);
+        const minimumTimeUntilTimeout = Math.max(ProtocolConstants.TimeoutTime - timeSinceOldestUnacknowledgedMsg, ProtocolConstants.TimeoutTime - timeSinceLastReceivedSomeData, ProtocolConstants.TimeoutTime - timeSinceLastTimeout, 500);
         this._outgoingAckTimeout = setTimeout(() => {
             this._outgoingAckTimeout = null;
             this._recvAckCheck();
@@ -719,18 +781,13 @@ class PersistentProtocol {
             return;
         }
         this._incomingAckId = this._incomingMsgId;
-        const msg = ( new ProtocolMessage(3 , 0, this._incomingAckId, getEmptyBuffer()));
+        const msg = ( new ProtocolMessage(ProtocolMessageType.Ack, 0, this._incomingAckId, getEmptyBuffer()));
         this._socketWriter.write(msg);
     }
     _sendKeepAlive() {
         this._incomingAckId = this._incomingMsgId;
-        const msg = ( new ProtocolMessage(
-            9 ,
-            0,
-            this._incomingAckId,
-            getEmptyBuffer()
-        ));
+        const msg = ( new ProtocolMessage(ProtocolMessageType.KeepAlive, 0, this._incomingAckId, getEmptyBuffer()));
         this._socketWriter.write(msg);
     }
 }
-export { BufferedEmitter, ChunkStream, Client, PersistentProtocol, Protocol, SocketDiagnostics };
+export { BufferedEmitter, ChunkStream, Client, PersistentProtocol, Protocol, ProtocolConstants, SocketCloseEventType, SocketDiagnostics, SocketDiagnosticsEventType };

package/vscode/src/vs/base/parts/storage/common/storage.js

@@ -185,7 +185,9 @@ class Storage extends Disposable {
         });
     }
     async flush(delay) {
-        if (!this.hasPending) {
+        if (this.state === StorageState.Closed ||
+            this.pendingClose
+        ) {
             return;
         }
         return this.doFlush(delay);