@fluidframework/driver-base 2.0.0-dev.1.4.6.106135 → 2.0.0-dev.2.3.0.115467

package/src/documentDeltaConnection.ts

@@ -5,10 +5,11 @@
 
 import { assert } from "@fluidframework/common-utils";
 import {
+    IAnyDriverError,
     IDocumentDeltaConnection,
     IDocumentDeltaConnectionEvents,
 } from "@fluidframework/driver-definitions";
-import { createGenericNetworkError, IAnyDriverError } from "@fluidframework/driver-utils";
+import { createGenericNetworkError } from "@fluidframework/driver-utils";
 import {
     ConnectionMode,
     IClientConfiguration,
@@ -310,17 +311,30 @@ export class DocumentDeltaConnection
     }
 
     /**
-     * Disconnect from the websocket, and permanently disable this DocumentDeltaConnection.
+     * Disconnect from the websocket and close the websocket too.
+     */
+    protected closeSocket(error: IAnyDriverError) {
+        this.disconnect(error);
+    }
+
+    /**
+     * Disconnect from the websocket, and permanently disable this DocumentDeltaConnection and close the socket.
+     * However the OdspDocumentDeltaConnection differ in dispose as in there we don't close the socket. There is no
+     * multiplexing here, so we need to close the socket here.
      */
     public dispose() {
-        this.disposeCore(
-            false, // socketProtocolError
-            createGenericNetworkError(
-                // pre-0.58 error message: clientClosingConnection
-                "Client closing delta connection", { canRetry: true }, { driverVersion }));
+        this.logger.sendTelemetryEvent({
+            eventName: "ClientClosingDeltaConnection",
+            driverVersion,
+            details: JSON.stringify({ disposed: this._disposed, socketConnected: this.socket.connected }),
+        });
+        this.disconnect(createGenericNetworkError(
+            // pre-0.58 error message: clientClosingConnection
+            "Client closing delta connection", { canRetry: true }, { driverVersion }),
+        );
     }
 
-    protected disposeCore(socketProtocolError: boolean, err: IAnyDriverError) {
+    protected disconnect(err: IAnyDriverError) {
         // Can't check this.disposed here, as we get here on socket closure,
         // so _disposed & socket.connected might be not in sync while processing
         // "dispose" event.
@@ -335,17 +349,30 @@ export class DocumentDeltaConnection
         // to prevent normal messages from being emitted.
         this._disposed = true;
 
+        // Let user of connection object know about disconnect. This has to happen in between setting _disposed and
+        // removing all listeners!
+        this.emit("disconnect", err);
+        this.logger.sendTelemetryEvent({
+            eventName: "AfterDisconnectEvent",
+            driverVersion,
+            details: JSON.stringify({
+                socketConnected: this.socket.connected,
+                disconnectListenerCount: this.listenerCount("disconnect"),
+            }),
+        });
+        // user of DeltaConnection should have processed "disconnect" event and removed all listeners. Not clear
+        // if we want to enforce that, as some users (like LocalDocumentService) do not unregister any handlers
+        // assert(this.listenerCount("disconnect") === 0, "'disconnect` events should be processed synchronously");
+
         this.removeTrackedListeners();
-        this.disconnect(socketProtocolError, err);
+        this.disconnectCore();
     }
 
     /**
      * Disconnect from the websocket.
-     * @param socketProtocolError - true if error happened on socket / socket.io protocol level
-     * (not on Fluid protocol level)
      * @param reason - reason for disconnect
      */
-    protected disconnect(socketProtocolError: boolean, reason: IAnyDriverError) {
+    protected disconnectCore() {
         this.socket.disconnect();
     }
 
@@ -364,11 +391,15 @@ export class DocumentDeltaConnection
             getMaxInternalSocketReconnectionAttempts() + 1;
 
         this._details = await new Promise<IConnected>((resolve, reject) => {
-            const fail = (socketProtocolError: boolean, err: IAnyDriverError) => {
-                this.disposeCore(socketProtocolError, err);
+            const failAndCloseSocket = (err: IAnyDriverError) => {
+                this.closeSocket(err);
                 reject(err);
             };
 
+            const failConnection = (err: IAnyDriverError) => {
+                this.disconnect(err);
+                reject(err);
+            };
             // Listen for connection issues
             this.addConnectionListener("connect_error", (error) => {
                 internalSocketConnectionFailureCount++;
@@ -406,12 +437,12 @@ export class DocumentDeltaConnection
                     return;
                 }
 
-                fail(true, this.createErrorObject("connect_error", error));
+                failAndCloseSocket(this.createErrorObject("connect_error", error));
             });
 
             // Listen for timeouts
             this.addConnectionListener("connect_timeout", () => {
-                fail(true, this.createErrorObject("connect_timeout"));
+                failAndCloseSocket(this.createErrorObject("connect_timeout"));
             });
 
             this.addConnectionListener("connect_document_success", (response: IConnected) => {
@@ -430,7 +461,7 @@ export class DocumentDeltaConnection
                     // The only time we expect a mismatch in requested/actual is if we lack write permissions
                     // In this case we will get "read", even if we requested "write"
                     if (actualMode !== requestedMode) {
-                        fail(false, this.createErrorObject(
+                        failConnection(this.createErrorObject(
                             "connect_document_success",
                             "Connected in a different mode than was requested",
                             false,
@@ -439,7 +470,7 @@ export class DocumentDeltaConnection
                     }
                 } else {
                     if (actualMode === "write") {
-                        fail(false, this.createErrorObject(
+                        failConnection(this.createErrorObject(
                             "connect_document_success",
                             "Connected in write mode without write permissions",
                             false,
@@ -459,17 +490,14 @@ export class DocumentDeltaConnection
             // had a chance to register its handlers.
             this.addTrackedListener("disconnect", (reason) => {
                 const err = this.createErrorObject("disconnect", reason);
-                this.emit("disconnect", err);
-                fail(true, err);
+                failAndCloseSocket(err);
             });
 
             this.addTrackedListener("error", ((error) => {
-                // First, raise an error event, to give clients a chance to observe error contents
                 // This includes "Invalid namespace" error, which we consider critical (reconnecting will not help)
                 const err = this.createErrorObject("error", error, error !== "Invalid namespace");
-                this.emit("error", err);
                 // Disconnect socket - required if happened before initial handshake
-                fail(true, err);
+                failAndCloseSocket(err);
             }));
 
             this.addConnectionListener("connect_document_error", ((error) => {
@@ -482,14 +510,14 @@ export class DocumentDeltaConnection
 
                 // This is not an socket.io error - it's Fluid protocol error.
                 // In this case fail connection and indicate that we were unable to create connection
-                fail(false, this.createErrorObject("connect_document_error", error));
+                failConnection(this.createErrorObject("connect_document_error", error));
             }));
 
             this.socket.emit("connect_document", connectMessage);
 
             // Give extra 2 seconds for handshake on top of socket connection timeout
             this.socketConnectionTimeout = setTimeout(() => {
-                fail(false, this.createErrorObject("orderingServiceHandshakeTimeout"));
+                failConnection(this.createErrorObject("orderingServiceHandshakeTimeout"));
             }, timeout + 2000);
         });
 

package/src/index.ts

@@ -3,4 +3,4 @@
  * Licensed under the MIT License.
  */
 
-export * from "./documentDeltaConnection";
+export { DocumentDeltaConnection } from "./documentDeltaConnection";

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/driver-base";
-export const pkgVersion = "2.0.0-dev.1.4.6.106135";
+export const pkgVersion = "2.0.0-dev.2.3.0.115467";

package/lib/test/types/validateDriverBasePrevious.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=validateDriverBasePrevious.d.ts.map

package/lib/test/types/validateDriverBasePrevious.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"validateDriverBasePrevious.d.ts","sourceRoot":"","sources":["../../../src/test/types/validateDriverBasePrevious.ts"],"names":[],"mappings":""}

package/lib/test/types/validateDriverBasePrevious.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"validateDriverBasePrevious.js","sourceRoot":"","sources":["../../../src/test/types/validateDriverBasePrevious.ts"],"names":[],"mappings":"AAwBA,oDAAoD,CAChD,gDAAgD,EAAE,CAAC,CAAC;AAWxD,gDAAgD,CAC5C,oDAAoD,EAAE,CAAC,CAAC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n/*\n * THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.\n * Generated by fluid-type-validator in @fluidframework/build-tools.\n */\nimport * as old from \"@fluidframework/driver-base-previous\";\nimport * as current from \"../../index\";\n\ntype TypeOnly<T> = {\n    [P in keyof T]: TypeOnly<T[P]>;\n};\n\n/*\n* Validate forward compat by using old type in place of current type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"ClassDeclaration_DocumentDeltaConnection\": {\"forwardCompat\": false}\n*/\ndeclare function get_old_ClassDeclaration_DocumentDeltaConnection():\n    TypeOnly<old.DocumentDeltaConnection>;\ndeclare function use_current_ClassDeclaration_DocumentDeltaConnection(\n    use: TypeOnly<current.DocumentDeltaConnection>);\nuse_current_ClassDeclaration_DocumentDeltaConnection(\n    get_old_ClassDeclaration_DocumentDeltaConnection());\n\n/*\n* Validate back compat by using current type in place of old type\n* If breaking change required, add in package.json under typeValidation.broken:\n* \"ClassDeclaration_DocumentDeltaConnection\": {\"backCompat\": false}\n*/\ndeclare function get_current_ClassDeclaration_DocumentDeltaConnection():\n    TypeOnly<current.DocumentDeltaConnection>;\ndeclare function use_old_ClassDeclaration_DocumentDeltaConnection(\n    use: TypeOnly<old.DocumentDeltaConnection>);\nuse_old_ClassDeclaration_DocumentDeltaConnection(\n    get_current_ClassDeclaration_DocumentDeltaConnection());\n"]}