RDBC-210 fix promise was created but not returned

Author: gregolsky

src/Http/RequestExecutor.ts

@@ -2,7 +2,7 @@ import * as os from "os";
 import * as BluebirdPromise from "bluebird";
 import * as semaphore from "semaphore";
 import * as stream from "readable-stream";
-import { acquireSemaphore } from "../Utility/SemaphoreUtil";
+import { acquireSemaphore, AcquiredSemaphoreContext } from "../Utility/SemaphoreUtil";
 import { getLogger, ILogger } from "../Utility/LogUtil";
 import { Timer } from "../Primitives/Timer";
 import { ServerNode } from "./ServerNode";
@@ -327,54 +327,53 @@ export class RequestExecutor implements IDisposable {
             .then(() => this._nodeSelector.getFastestNode());
     }
 
-    protected _updateClientConfiguration(): PromiseLike<void> {
-        if (this._disposed) {
-            return BluebirdPromise.resolve(null);
-        }
+    private async _updateClientConfigurationInternal(): Promise<void> {
+        const oldDisableClientConfigurationUpdates = this._disableClientConfigurationUpdates;
+        this._disableClientConfigurationUpdates = true;
 
-        const updateClientConfigurationInternal = () => {
-            const oldDisableClientConfigurationUpdates = this._disableClientConfigurationUpdates;
-            this._disableClientConfigurationUpdates = true;
+        try {
+            if (this._disposed) {
+                return;
+            }
 
-            return BluebirdPromise.resolve()
-                .then(() => {
+            const command = new GetClientConfigurationCommand();
+            const { currentNode, currentIndex } = this.chooseNodeForRequest(command, null);
+            await this.execute(command, null, {
+                chosenNode: currentNode,
+                nodeIndex: currentIndex,
+                shouldRetry: false
+            });
 
-                    if (this._disposed) {
-                        return;
-                    }
+            const clientConfigOpResult = command.result;
+            if (!clientConfigOpResult) {
+                return;
+            }
 
-                    const command = new GetClientConfigurationCommand();
-                    const currentIndexAndNode2: CurrentIndexAndNode = this.chooseNodeForRequest(command, null);
-                    return this.execute(command, null, {
-                        chosenNode: currentIndexAndNode2.currentNode,
-                        nodeIndex: currentIndexAndNode2.currentIndex,
-                        shouldRetry: false
-                    })
-                        .then(() => command.result);
-                })
-                .then((clientConfigOpResult: GetClientConfigurationOperationResult) => {
-                    if (!clientConfigOpResult) {
-                        return;
-                    }
+            this._conventions.updateFrom(clientConfigOpResult.configuration);
+            this._clientConfigurationEtag = clientConfigOpResult.etag;
+        } catch (err) {
+            this._log.error(err, "Error getting client configuration.");
+        } finally {
+            this._disableClientConfigurationUpdates = oldDisableClientConfigurationUpdates;
+        }
+    }
 
-                    this._conventions.updateFrom(clientConfigOpResult.configuration);
-                    this._clientConfigurationEtag = clientConfigOpResult.etag;
+    protected async _updateClientConfiguration(): Promise<void> {
+        if (this._disposed) {
+            return;
+        }
 
-                })
-                .tapCatch(err => this._log.error(err, "Error getting client configuration."))
-                .finally(() => {
-                    this._disableClientConfigurationUpdates = oldDisableClientConfigurationUpdates;
-                });
-        };
+        let semAcquiredContext: AcquiredSemaphoreContext;
 
-        const semAcquiredContext = acquireSemaphore(this._updateClientConfigurationSemaphore);
-        const result = BluebirdPromise.resolve(semAcquiredContext.promise)
-            .then(() => updateClientConfigurationInternal())
-            .finally(() => {
+        try {
+            semAcquiredContext = acquireSemaphore(this._updateClientConfigurationSemaphore);
+            await semAcquiredContext.promise;
+            await this._updateClientConfigurationInternal();
+        } finally {
+            if (semAcquiredContext) {
                 semAcquiredContext.dispose();
-            });
-
-        return Promise.resolve(result);
+            }
+        }
     }
 
     public updateTopology(node: ServerNode, timeout: number, forceUpdate: boolean = false): Promise<boolean> {