Optimize connection strategy with multiple hosts through ordered caching of active and inactive database hosts

Author: sharadraju

doc/src/release_notes.rst

@@ -39,6 +39,12 @@ Thin Mode Changes
     matching. The search order is: the host name, then the subject alternative
     name (SAN), and then the service name.
 
+#) Connection Optimization(Internal): 
+   When connecting to a host, if the host is found to be unreachable, 
+   add that host to a cache(mark it as down). Subsequent requests to get
+   a connection will reorder the list of hosts to attempt making a connection
+   to so that the hosts which are marked as down are at the end of the list.
+
 #)  Fixed bug when ``sslServerDNMatch`` is set and the connect string is in Easy
     Connect format but a value for ``SSL_SERVER_DN_MATCH`` is not set in that
     connect string.

lib/thin/sqlnet/connStrategy.js

@@ -54,6 +54,7 @@ class ConnectDescription {
 class ConnStrategy {
   constructor() {
     this.nextOptToTry = 0;
+    this.reorderDescriptionList = 0;
     this.retryCount = 0;
     this.lastRetryCounter = 0;
     this.lastRetryConnectDescription = 0;
@@ -95,6 +96,10 @@ class ConnStrategy {
         this.retryCount = config.retryCount;
       }
     }
+    if (!this.reorderDescriptionList) {
+      this.descriptionList = SOLE_INST_DHCACHE.reorderDescriptionList(this.descriptionList);
+      this.reorderDescriptionList = true;
+    }
     /* We try the address list at least once and upto (1 + retryCount) times */
     for (let d = this.lastRetryConnectDescription; d < this.descriptionList.length; d++) {
       const desc = this.descriptionList[d];
@@ -108,6 +113,11 @@ class ConnStrategy {
         }
       }
       for (let i = this.lastRetryCounter; i <= this.retryCount; ++i) {
+        //Conn options must be reordered only when all options are tried
+        // i.e for retry and before the first try.
+        if (this.nextOptToTry == 0) {
+          cOpts = SOLE_INST_DHCACHE.reorderAddresses(cOpts);
+        }
         while (this.nextOptToTry < cOpts.length) {
           const copt = cOpts[this.nextOptToTry];
           this.lastRetryCounter = i;
@@ -174,4 +184,117 @@ async function createNode(str) {
   await navobj.navigate(cs);
   return cs;
 }
-module.exports = { createNode };
+
+
+class DownHostsCache {
+
+  constructor() {
+    // Timeout for each item in the cache
+    this.DOWN_HOSTS_TIMEOUT = 600;
+    // Minimum amount of time between each refresh
+    this.MIN_TIME_BETWEEN_REFRESH = 60;
+    // DownHostsCache Map
+    this.downHostsCacheMap = new Map();
+    // Last Refresh Time
+    this.lastRefreshTime = 0;
+  }
+
+  /**
+   * Add an address to the cache
+   *
+   * @param connOption
+   *            address to be cached
+   * @return Map with address as key and time of insertion as value
+   */
+  markDownHost(addr) {
+    return this.downHostsCacheMap.set(addr, Date.now());
+  }
+
+  // Remove elements older than DownHostsTimeout
+  refreshCache() {
+    if (Date.now() - this.MIN_TIME_BETWEEN_REFRESH * 1000 > this.lastRefreshTime) {
+      this.downHostsCacheMap.forEach((value, key) => {
+        const entryTime = value;
+        if (entryTime != null && ((Date.now() - this.DOWN_HOSTS_TIMEOUT * 1000) > entryTime)) {
+          this.downHostsCacheMap.delete(key);
+        }
+      });
+      this.lastRefreshTime = Date.now();
+    }
+  }
+
+  /**
+   * Reorder addresses such that cached elements
+   * occur at the end of the array.
+   */
+  reorderAddresses(cOpts) {
+    this.refreshCache();
+
+    let topIdx = 0, btmIdx = cOpts.length - 1;
+
+    while (topIdx < btmIdx) {
+
+      // increment topIdx if the address is not cached
+      while (topIdx <= btmIdx
+          && !this.isDownHostsCached(cOpts[topIdx]))
+        topIdx++;
+
+      // decrement btmIdx if address is cached
+      while (btmIdx >= topIdx
+          && this.isDownHostsCached(cOpts[btmIdx]))
+        btmIdx--;
+
+      // swap cached with uncached
+      if (topIdx < btmIdx)
+        [cOpts[topIdx], cOpts[btmIdx]] = [cOpts[btmIdx], cOpts[topIdx]];
+
+    }
+    return cOpts;
+  }
+
+  isDownDescCached(desc) {
+    //const desc = this.descriptionList[d];
+    //let cOpts = new Array();
+    const cOpts = desc.getConnectOptions();
+    for (let i = 0; i < cOpts.length; i++) {
+      if (!this.isDownHostsCached(cOpts[i]))
+        return false;
+    }
+    return true;
+  }
+  /**
+   * Reorder description list such that description with all connection options in downcache 
+   * is pushed to the end of the description list
+   */
+  reorderDescriptionList(descs) {
+    this.refreshCache();
+
+    let topIdx = 0, btmIdx = descs.length - 1;
+
+    while (topIdx < btmIdx) {
+
+      // increment topIdx if the address is not cached
+      while (topIdx <= btmIdx
+          && !this.isDownDescCached(descs[topIdx]))
+        topIdx++;
+
+      // decrement btmIdx if address is cached
+      while (btmIdx >= topIdx
+          && this.isDownDescCached(descs[btmIdx]))
+        btmIdx--;
+
+      // swap cached with uncached
+      if (topIdx < btmIdx) {
+        [descs[topIdx], descs[btmIdx]] = [descs[btmIdx], descs[topIdx]];
+      }
+    }
+    return descs;
+  }
+  // Return if a host is cached
+  isDownHostsCached(copt) {
+    return this.downHostsCacheMap.has(copt.host);
+  }
+}
+// Single instance
+const SOLE_INST_DHCACHE = new DownHostsCache();
+module.exports = { createNode, SOLE_INST_DHCACHE };

lib/thin/sqlnet/networkSession.js

@@ -37,7 +37,7 @@ const { Buffer } = require('buffer');
 const EzConnect = require("./ezConnectResolver.js");
 const { NLParamParser, tnsnamesFilePath } = require("./paramParser.js");
 const process = require('process');
-
+const downHostInstance = require("./connStrategy.js").SOLE_INST_DHCACHE;
 /**
  *
  * @param {string} userConfig
@@ -319,7 +319,8 @@ class NetworkSession {
           connected = await this.connect2(address);
         }
       } catch (err) {
-        if (err.message.startsWith('NJS-510')) {
+        if (err.message.startsWith('NJS-510') && !this.ntAdapter.connected) {
+          downHostInstance.markDownHost(address.host, Date.now()); // mark the host as down
           this.ntAdapter.connected = true; // Pretend as connected
         }
         if (this.ntAdapter) {