oracledb 6.0.3 → 6.2.0

package/lib/thin/protocol/messages/withData.js

@@ -57,6 +57,7 @@ class MessageWithData extends Message {
     this.inFetch = false;
     this.parseOnly = false;
     this.resultSetsToSetup = [];
+    this.deferredErr = null;
   }
 
   /**
@@ -65,11 +66,12 @@ class MessageWithData extends Message {
   processMessage(buf, messageType) {
     if (messageType === constants.TNS_MSG_TYPE_DESCRIBE_INFO) {
       buf.skipBytesChunked();
+      const prevQueryVars = this.statement.queryVars;
       this.statement.queryVars = [];
       this.statement.numQueryVars = 0;
       this.statement.bufferRowCount = 0;
       this.statement.bufferRowIndex = 0;
-      this.processDescribeInfo(buf, this.resultSet);
+      this.processDescribeInfo(buf, this.resultSet, prevQueryVars);
       this.outVariables = this.statement.queryVars;
     } else if (messageType === constants.TNS_MSG_TYPE_ROW_HEADER) {
       this.processRowHeader(buf);
@@ -115,15 +117,30 @@ class MessageWithData extends Message {
       this.errorOccurred = false;
       this.statement.moreRowsToFetch = false;
     } else if (this.errorInfo.num !== 0 && this.errorInfo.cursorId !== 0) {
-      this.connection._addCursorToClose(this.statement.cursorId);
       this.connection.statementCache.delete(this.statement.sql);
+      this.statement.returnToCache = false;
     }
     if (this.errorInfo.batchErrors) {
       this.errorOccurred = false;
     }
   }
 
-  processDescribeInfo(buf, resultSet) {
+  //---------------------------------------------------------------------------
+  // If we have fetched this column earlier, we set that
+  // fetch type for the describe info variable received
+  // assuming the returned column order is same as previous.
+  //---------------------------------------------------------------------------
+  _adjustFetchType(pVar, cVar) {
+    if ((cVar.fetchInfo.dbType._oraTypeNum === constants.TNS_DATA_TYPE_CLOB
+       && pVar.fetchInfo.fetchType._oraTypeNum === constants.TNS_DATA_TYPE_LONG)
+        || (cVar.fetchInfo.dbType._oraTypeNum === constants.TNS_DATA_TYPE_BLOB
+          && pVar.fetchInfo.fetchType._oraTypeNum === constants.TNS_DATA_TYPE_LONG_RAW)) {
+      cVar.type = pVar.fetchInfo.fetchType;
+      cVar.maxSize = pVar.maxSize;
+    }
+  }
+
+  processDescribeInfo(buf, resultSet, prevQueryVars) {
     const statement = resultSet.statement;
     buf.skipUB4();                              // max row size
     statement.numQueryVars = buf.readUB4();
@@ -133,6 +150,9 @@ class MessageWithData extends Message {
     resultSet.metadata = [];
     for (let i = 0; i < statement.numQueryVars; i++) {
       const variable = this.processColumnInfo(buf, i + 1);
+      if (prevQueryVars && i < prevQueryVars.length) {
+        this._adjustFetchType(prevQueryVars[i], variable);
+      }
       statement.queryVars.push(variable);
       resultSet.metadata.push(variable.fetchInfo);
     }
@@ -257,8 +277,7 @@ class MessageWithData extends Message {
     buf.skipUB2();                              // buffer length
     let numBytes = buf.readUB4();
     if (numBytes > 0) {
-      buf.skipUB1();                            // skip repeated length
-      this.getBitVector(buf, numBytes);
+      this.bitVector = Buffer.from(buf.readBytesWithLength());
     }
     numBytes = buf.readUB4();
     if (numBytes > 0) {
@@ -267,28 +286,28 @@ class MessageWithData extends Message {
   }
 
   isDuplicateData(columnName) {
-    if (this.bitVector === null || this.bitVector === undefined) {
+    if (!this.bitVector) {
       return false;
     }
-    let byteNum = Math.floor(columnName / 8);
-    let bitNum = columnName % 8;
+    const byteNum = Math.floor(columnName / 8);
+    const bitNum = columnName % 8;
     return (this.bitVector[byteNum] & (1 << bitNum)) === 0;
   }
 
   processRowData(buf) {
     let value;
-    for (let [col, variable] of this.outVariables.entries()) {
+    for (const [col, variable] of this.outVariables.entries()) {
       if (variable.isArray) {
         variable.numElementsInArray = buf.readUB4();
-        let values = new Array(variable.numElementsInArray).fill(null);
+        const values = new Array(variable.numElementsInArray).fill(null);
         for (let pos = 0; pos < variable.numElementsInArray; pos++) {
           value = this.processColumnData(buf, variable, pos);
           values[pos] = value;
         }
         variable.values[this.rowIndex] = values;
       } else if (this.statement.isReturning) {
-        let numRows = buf.readUB4();
-        let values = Array(numRows).fill(null);
+        const numRows = buf.readUB4();
+        const values = Array(numRows).fill(null);
         for (let j = 0; j < numRows; j++) {
           values[j] = this.processColumnData(buf, variable, j);
         }
@@ -331,7 +350,7 @@ class MessageWithData extends Message {
     }
     this.outVariables = [];
     for (let i = 0; i < numBinds; i++) {              // bind directions
-      let bindInfo = this.statement.bindInfoList[i];
+      const bindInfo = this.statement.bindInfoList[i];
       bindInfo.bindDir = buf.readUInt8();
       if (bindInfo.bindDir === constants.TNS_BIND_DIR_INPUT) {
         continue;
@@ -383,11 +402,11 @@ class MessageWithData extends Message {
       if (!this.inFetch) {
         colValue = buf.readStr(constants.CSFRM_IMPLICIT);
       } else {
-        let numBytes = buf.readUInt8();
+        const numBytes = buf.readUInt8();
         if (isNullLength(numBytes)) {
           colValue = null;
         } else {
-          let rowid = buf.readRowID();
+          const rowid = buf.readRowID();
           colValue = utils.encodeRowID(rowid);
         }
       }
@@ -406,7 +425,7 @@ class MessageWithData extends Message {
       if (colValue !== null)
         colValue = parseFloat(colValue);
     } else if (oraTypeNum === constants.TNS_DATA_TYPE_CURSOR) {
-      let numBytes = buf.readUInt8();
+      const numBytes = buf.readUInt8();
       if (isNullLength(numBytes)) {
         colValue = null;
       } else {
@@ -425,7 +444,7 @@ class MessageWithData extends Message {
     } else if (oraTypeNum === constants.TNS_DATA_TYPE_BOOLEAN) {
       colValue = buf.readBool();
     } else if (oraTypeNum === constants.TNS_DATA_TYPE_CLOB || oraTypeNum === constants.TNS_DATA_TYPE_BLOB) {
-      let bvalue = buf.readUB4();
+      const bvalue = buf.readUB4();
       if (bvalue > 0) { // Non Null data in column
         colValue = new ThinLobImpl();
         const length = buf.readUB8();
@@ -454,7 +473,7 @@ class MessageWithData extends Message {
       if (actualNumBytes < 0 && oraTypeNum === constants.TNS_DATA_TYPE_BOOLEAN) {
         colValue = null;
       } else if (actualNumBytes !== 0 && colValue !== null) {
-        errors.throwErr(errors.ERR_INSUFFICIENT_BUFFER_FOR_BINDS);
+        this.saveDeferredErr(errors.ERR_INSUFFICIENT_BUFFER_FOR_BINDS);
       }
     } else if (oraTypeNum === constants.TNS_DATA_TYPE_LONG || oraTypeNum === constants.TNS_DATA_TYPE_LONG_RAW || variable.maxSize > buf.caps.maxStringSize) {
       buf.skipSB4();                            // null indicator
@@ -497,31 +516,25 @@ class MessageWithData extends Message {
       buf.skip(numBytes);
     }
     if (this.arrayDmlRowCounts) {
-      let numRows = buf.readUB4();
-      let rowCounts = this.options.dmlRowCounts = [];
+      const numRows = buf.readUB4();
+      const rowCounts = this.options.dmlRowCounts = [];
       for (let i = 0; i < numRows; i++) {
-        let rowCount = buf.readUB8();
+        const rowCount = buf.readUB8();
         rowCounts.push(rowCount);
       }
     }
   }
 
-  process(buf) {
-    this.bitVector = this.savedBitVector;
-    super.process(buf);
-  }
-
-  savePoint(buf) {
-    this.savedBitVector = this.bitVector;
-    super.savePoint(buf);
-  }
-
   async postProcess() {
+    if (this.deferredErr) {
+      throw this.deferredErr;
+    }
+
     if (this.outVariables) {
       for (const variable of this.outVariables) {
         if (variable.isArray) {
-          for (let pos = 0; pos < variable.numElementsInArray; pos++) {
-            if (variable.outConverter) {
+          if (variable.outConverter) {
+            for (let pos = 0; pos < variable.numElementsInArray; pos++) {
               variable.values[0][pos] = await variable.outConverter(variable.values[0][pos]);
             }
           }
@@ -546,8 +559,10 @@ class MessageWithData extends Message {
             variable.type = variable.fetchInfo.fetchType;
             variable.maxSize = constants.TNS_MAX_LONG_LENGTH;
           }
-          resultSet.statement.requiresDefine = true;
-          resultSet.statement.noPrefetch = true;
+          if (!resultSet.statement.noPrefetch) {
+            resultSet.statement.requiresDefine = true;
+            resultSet.statement.noPrefetch = true;
+          }
         }
       }
     }
@@ -580,10 +595,6 @@ class MessageWithData extends Message {
     if (this.statement.numQueryVars % 8 > 0) {
       numBytes += 1;
     }
-    this.getBitVector(buf, numBytes);
-  }
-
-  getBitVector(buf, numBytes) {
     this.bitVector = Buffer.from(buf.readBytes(numBytes));
   }
 
@@ -651,15 +662,15 @@ class MessageWithData extends Message {
         const objType = variable.objType;
         buf.writeUB4(objType.oid.length);
         buf.writeBytesWithLength(objType.oid);
-        buf.writeUB4(objType.version);
+        buf.writeUB2(objType.version);
       } else {
         buf.writeUB4(0);                        // OID
-        buf.writeUB4(0);                        // version
+        buf.writeUB2(0);                        // version
       }
       if (variable.type._csfrm !== 0) {
-        buf.writeUB4(constants.TNS_CHARSET_UTF8);
+        buf.writeUB2(constants.TNS_CHARSET_UTF8);
       } else {
-        buf.writeUB4(0);
+        buf.writeUB2(0);
       }
       buf.writeUInt8(variable.type._csfrm);
       buf.writeUB4(lobPrefetchLength);          // max chars (LOB prefetch)
@@ -670,14 +681,14 @@ class MessageWithData extends Message {
   }
 
   writeBindParamsRow(buf, params, pos) {
-    let offset = this.offset;
+    const offset = this.offset;
     let foundLong = false;
     for (const bindInfo of params) {
       if (bindInfo.isReturnBind)
         continue;
-      let variable = bindInfo.bindVar;
+      const variable = bindInfo.bindVar;
       if (variable.isArray) {
-        let numElements = variable.values.length;
+        const numElements = variable.values.length;
         buf.writeUB4(numElements);
         for (let i = 0; i < numElements; i++) {
           this.writeBindParamsColumn(buf, variable, variable.values[i]);
@@ -800,7 +811,7 @@ class MessageWithData extends Message {
     for (let i = 0; i < numResults; i++) {
       const numBytes = buf.readUInt8();
       buf.skipBytes(numBytes);
-      let childResultSet = this.createCursorFromDescribe(buf);
+      const childResultSet = this.createCursorFromDescribe(buf);
       childResultSet.statement.cursorId = buf.readUB2();
       this.options.implicitResultSet.push(childResultSet);
     }

package/lib/thin/protocol/oson.js

@@ -352,7 +352,7 @@ class OsonFieldNamesSegment extends GrowableBuffer {
   //---------------------------------------------------------------------------
   _examineNode(value) {
     if (Array.isArray(value)) {
-      for (let element of value) {
+      for (const element of value) {
         this._examineNode(element);
       }
     } else if (value && Array.isArray(value.fields)) {
@@ -416,10 +416,11 @@ class OsonTreeSegment extends GrowableBuffer {
   //---------------------------------------------------------------------------
   _encodeArray(value, fnamesSeg) {
     this._encodeContainer(constants.TNS_JSON_TYPE_ARRAY, value.length);
-    let offsetsBufPos = 0;
-    const offsetsBuf = this.reserveBytes(value.length * 4);
-    for (let element of value) {
-      offsetsBuf.writeUInt32BE(this.pos, offsetsBufPos);
+    const len = value.length * 4;
+    const pos = this.reserveBytes(len);
+    let offsetsBufPos = pos;
+    for (const element of value) {
+      this.buf.writeUInt32BE(this.pos, offsetsBufPos);
       offsetsBufPos += 4;
       this.encodeNode(element, fnamesSeg);
     }
@@ -456,19 +457,21 @@ class OsonTreeSegment extends GrowableBuffer {
   _encodeObject(value, fnamesSeg) {
     const numChildren = value.values.length;
     this._encodeContainer(constants.TNS_JSON_TYPE_OBJECT, numChildren);
-    let fieldIdOffset = 0;
-    let valueOffset = numChildren * fnamesSeg.fieldIdSize;
-    const buf = this.reserveBytes(numChildren * (fnamesSeg.fieldIdSize + 4));
+    const len = numChildren * (fnamesSeg.fieldIdSize + 4);
+    const pos = this.reserveBytes(len);
+    let fieldIdOffset = pos;
+    let valueOffset = pos + (numChildren * fnamesSeg.fieldIdSize);
+
     for (let i = 0; i < value.fields.length; i++) {
       const fieldName = fnamesSeg.fieldNamesMap.get(value.fields[i]);
       if (fnamesSeg.fieldIdSize == 1) {
-        buf[fieldIdOffset] = fieldName.fieldId;
+        this.buf[fieldIdOffset] = fieldName.fieldId;
       } else if (fnamesSeg.fieldIdSize == 2) {
-        buf.writeUInt16BE(fieldName.fieldId, fieldIdOffset);
+        this.buf.writeUInt16BE(fieldName.fieldId, fieldIdOffset);
       } else {
-        buf.writeUInt32BE(fieldName.fieldId, fieldIdOffset);
+        this.buf.writeUInt32BE(fieldName.fieldId, fieldIdOffset);
       }
-      buf.writeUInt32BE(this.pos, valueOffset);
+      this.buf.writeUInt32BE(this.pos, valueOffset);
       fieldIdOffset += fnamesSeg.fieldIdSize;
       valueOffset += 4;
       this.encodeNode(value.values[i], fnamesSeg);
@@ -627,12 +630,12 @@ class OsonEncoder extends GrowableBuffer {
       this.writeUInt16BE(0);
 
       // write array of hash ids
-      for (let fieldName of fnamesSeg.fieldNames) {
+      for (const fieldName of fnamesSeg.fieldNames) {
         this.writeUInt8(fieldName.hashId);
       }
 
       // write array of field name offsets
-      for (let fieldName of fnamesSeg.fieldNames) {
+      for (const fieldName of fnamesSeg.fieldNames) {
         if (fnamesSeg.pos < 65536) {
           this.writeUInt16BE(fieldName.offset);
         } else {

package/lib/thin/protocol/packet.js

@@ -31,10 +31,10 @@ const { Buffer } = require('buffer');
 const constants = require("./constants.js");
 const oson = require('./oson.js');
 const utils = require('./utils.js');
+const errors = require("../../errors.js");
 
 const TNS_BASE64_ALPHABET_ARRAY = Buffer.from("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", 'utf8');
 
-
 /**
  * Class used for byte chunks used in the ChunkedBytesBuffer.
  */
@@ -51,7 +51,7 @@ class BytesChunk {
     if (remainder > 0) {
       this.allocLen += (constants.CHUNKED_BYTES_CHUNK_SIZE - remainder);
     }
-    this.buf = Buffer.alloc(this.allocLen);
+    this.buf = Buffer.allocUnsafe(this.allocLen);
     this.actualLen = 0;
   }
 
@@ -132,6 +132,7 @@ class ChunkedBytesBuffer {
  *
  * @class ReadPacket
  */
+
 class ReadPacket extends BaseBuffer {
 
   /**
@@ -139,8 +140,9 @@ class ReadPacket extends BaseBuffer {
    * @param {Object} adapter used for sending/receiving data
    * @param {Object} capabilities
    */
+
   constructor(nsi, caps) {
-    super(nsi.sAtts.sdu);
+    super();
     this.nsi = nsi;
     this.caps = caps;
     this.chunkedBytesBuf = new ChunkedBytesBuffer();
@@ -227,7 +229,7 @@ class ReadPacket extends BaseBuffer {
     if (inChunkedRead) {
       buf = this.chunkedBytesBuf.getBuf(numBytes);
     } else {
-      buf = Buffer.alloc(numBytes);
+      buf = Buffer.allocUnsafe(numBytes);
     }
 
     // copy the bytes to the buffer from the remainder of this packet
@@ -324,23 +326,23 @@ class ReadPacket extends BaseBuffer {
 
     // Handle physical rowid
     if (buf && buf[0] === 1) {
-      let rba = buf.readUInt32BE(1);
-      let partitionID = buf.readUInt16BE(5);
-      let blockNum = buf.readUInt32BE(7);
-      let slotNum = buf.readUInt16BE(11);
+      const rba = buf.readUInt32BE(1);
+      const partitionID = buf.readUInt16BE(5);
+      const blockNum = buf.readUInt32BE(7);
+      const slotNum = buf.readUInt16BE(11);
       return utils.encodeRowID({rba, partitionID, blockNum, slotNum});
     }
 
     // handle logical rowid
     let outputLen = Math.floor(inputLen / 3) * 4;
-    let remainder = inputLen % 3;
+    const remainder = inputLen % 3;
     if (remainder === 1) {
       outputLen += 1;
     } else if (remainder === 2) {
       outputLen += 3;
     }
 
-    let outputValue =  Buffer.alloc(outputLen);
+    const outputValue =  Buffer.allocUnsafe(outputLen);
     inputLen -= 1;
     outputValue[0] = 42;
     outputOffset += 1;
@@ -385,16 +387,19 @@ class ReadPacket extends BaseBuffer {
   }
 
   readRowID() {
-    let rba = this.readUB4();
-    let partitionID = this.readUB2();
+    const rba = this.readUB4();
+    const partitionID = this.readUB2();
     this.skipUB1();
-    let blockNum = this.readUB4();
-    let slotNum = this.readUB2();
+    const blockNum = this.readUB4();
+    const slotNum = this.readUB2();
     return {rba, partitionID, blockNum, slotNum};
   }
 
   skipBytesChunked() {
     const numBytes = this.readUInt8();
+    if (numBytes === 0 || numBytes === constants.TNS_NULL_LENGTH_INDICATOR) {
+      return;
+    }
     if (numBytes !== constants.TNS_LONG_LENGTH_INDICATOR) {
       this.skipBytes(numBytes);
     } else {
@@ -407,6 +412,23 @@ class ReadPacket extends BaseBuffer {
     }
   }
 
+  readNullTerminatedBytes(maxSize = 50) {
+    let offset = 0;
+    const tmp = Buffer.allocUnsafe(maxSize);
+    while (offset < maxSize) {
+      tmp[offset] = this.readUInt8();
+      if (tmp[offset] === 0) {
+        break;
+      }
+      offset = offset + 1;
+    }
+    if (offset === maxSize) {
+      const reason = `Byte Arrray Exceeded MaxSize ${maxSize}`;
+      errors.throwErr(errors.ERR_INTERNAL, reason);
+    }
+    return tmp.subarray(0, offset + 1);
+  }
+
 }
 
 

package/lib/thin/protocol/utils.js

@@ -43,7 +43,7 @@ function _convertBase64(result, value, size, offset) {
 function encodeRowID(rowID) {
   let offset = 0;
   if (rowID.rba !== 0 || rowID.partitionID !== 0 || rowID.blockNum !== 0 || rowID.slotNum != 0) {
-    let result = Buffer.alloc(constants.TNS_MAX_ROWID_LENGTH);
+    const result = Buffer.allocUnsafe(constants.TNS_MAX_ROWID_LENGTH);
     offset = _convertBase64(result, rowID.rba, 6, offset);
     offset = _convertBase64(result, rowID.partitionID, 3, offset);
     offset = _convertBase64(result, rowID.blockNum, 6, offset);
@@ -59,7 +59,7 @@ function setObfuscatedValue(value) {
   const bytes = Buffer.from(value, 'utf8');
   const len = Buffer.byteLength(value);
 
-  let arr = [];
+  const arr = [];
   for (let i = 0; i < len; i++) {
     arr.push(buf[i] ^ bytes[i]);
   }

package/lib/thin/resultSet.js

@@ -68,10 +68,10 @@ class ThinResultSetImpl extends ResultSetImpl {
   // Returns rows fetched to the common layer in array format
   //---------------------------------------------------------------------------
   _processRows(numRowsFetched) {
-    let rows = [];
-    let bufferRowIndex = this.statement.bufferRowIndex;
+    const rows = [];
+    const bufferRowIndex = this.statement.bufferRowIndex;
     for (let row = bufferRowIndex; row < bufferRowIndex + numRowsFetched; row++) {
-      let rowObj = [];
+      const rowObj = [];
       for (let col = 0; col < this.statement.numQueryVars; col++) {
         rowObj.push(this.statement.queryVars[col].values[row]);
       }
@@ -99,13 +99,13 @@ class ThinResultSetImpl extends ResultSetImpl {
     } else {
       // We fetch for the required number of row
       options.fetchArraySize = options.fetchArraySize - (this.statement.bufferRowCount - this.statement.bufferRowIndex);
-      let prevBufferRowCount = this.statement.bufferRowCount;
+      const prevBufferRowCount = this.statement.bufferRowCount;
       if (this.statement.moreRowsToFetch && options.fetchArraySize > 0) {
         await this._fetchMoreRows(options);
       }
       options.fetchArraySize = numRows || this.options.fetchArraySize;
       if (prevBufferRowCount === this.statement.bufferRowCount) {
-        let numRowsFetched = this.statement.bufferRowCount - this.statement.bufferRowIndex;
+        const numRowsFetched = this.statement.bufferRowCount - this.statement.bufferRowIndex;
         this.statement.bufferRowCount = 0;
         if (numRowsFetched > 0) {
           return this._processRows(numRowsFetched);
@@ -113,7 +113,7 @@ class ThinResultSetImpl extends ResultSetImpl {
         return [];
       }
     }
-    let numRowsFetched = this.statement.bufferRowCount - this.statement.bufferRowIndex;
+    const numRowsFetched = this.statement.bufferRowCount - this.statement.bufferRowIndex;
     return this._processRows(numRowsFetched);
   }
 

package/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,9 +96,13 @@ 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++) {
-      let desc = this.descriptionList[d];
+      const desc = this.descriptionList[d];
       let cOpts = new Array();
       cOpts = desc.getConnectOptions();
       let delay = desc.delayInMillis;
@@ -108,8 +113,13 @@ 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) {
-          let copt = cOpts[this.nextOptToTry];
+          const copt = cOpts[this.nextOptToTry];
           this.lastRetryCounter = i;
           this.lastRetryConnectDescription = d;
           this.nextOptToTry++;
@@ -150,7 +160,7 @@ async function createNode(str) {
   else
     nvpair = str; //Already a NVPair
 
-  let arg = nvpair.name.toUpperCase();
+  const arg = nvpair.name.toUpperCase();
   let navobj = null;
   switch (arg) {
     case "ADDRESS":
@@ -170,8 +180,123 @@ async function createNode(str) {
         `unknown top element ${arg}`);
   }
   navobj.initFromNVPair(nvpair);
-  let cs = new ConnStrategy();
+  const cs = new ConnStrategy();
   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;
+  }
+  /**
+   * Return if a desc is cached.
+   * A desc is cached if all the connection options(addresses)
+   * in that description are cached.
+   */
+  isDownDescCached(desc) {
+    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 desc is not cached
+      while (topIdx <= btmIdx
+          && !this.isDownDescCached(descs[topIdx]))
+        topIdx++;
+
+      // decrement btmIdx if desc 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 };