Connection and protocol optimizations

Author: sharadraju

doc/src/release_notes.rst

@@ -31,6 +31,9 @@ Common Changes
 Thin Mode Changes
 +++++++++++++++++
 
+#)  Add support to improve Connection Establishment Latency for DB
+    versions 23.3 onwards.
+
 #)  Fixed bug in handling server to client piggybacks which are sometimes
     received during Authentcation phase.
     `Issue #1589 <https://github.com/oracle/node-oracledb/issues/1589>`__.

lib/thin/connection.js

@@ -32,7 +32,7 @@ const ThinResultSetImpl = require('./resultSet.js');
 const ThinLobImpl  = require("./lob.js");
 const Protocol = require("./protocol/protocol.js");
 const { BaseBuffer } = require('./protocol/buffer.js');
-const {NetworkSession:nsi, getConnectionInfo} = require("./sqlnet/networkSession.js");
+const {NetworkSession:nsi} = require("./sqlnet/networkSession.js");
 const { Statement } = require("./statement");
 const thinUtil = require('./util');
 const sqlNetConstants = require('./sqlnet/constants.js');
@@ -49,6 +49,8 @@ const finalizationRegistry = new global.FinalizationRegistry((heldValue) => {
 class TDSBuffer extends BaseBuffer {
 }
 
+const connectionCookies = new Map();
+
 class ThinConnectionImpl extends ConnectionImpl {
 
   /**
@@ -457,6 +459,26 @@ class ThinConnectionImpl extends ConnectionImpl {
     return (this._pool) ? true : false;
   }
 
+  //---------------------------------------------------------------------------
+  // getConnectionCookieByUUID()
+  //
+  // It fetches from map which keeps keyname as UUID+ServiceName.
+  // UUID identifies the CDB instance and ServiceName identifies the
+  // entity within a PDB which uniquely identifies a pdb instance.
+  //---------------------------------------------------------------------------
+  getConnectionCookieByUUID(uuid) {
+    let cookie;
+    if (uuid) {
+      const key = uuid + ((this.serviceName) ? this.serviceName : this.sid);
+      cookie = connectionCookies.get(key);
+      if (!cookie) {
+        cookie = {};
+        connectionCookies.set(key, cookie);
+      }
+    }
+    return cookie;
+  }
+
   /**
    *
    * @param {object} params  Configuration of the connection
@@ -495,6 +517,7 @@ class ThinConnectionImpl extends ConnectionImpl {
     this._clientInfoModified = false;
     this._module = "";
     this._moduleModified = false;
+    this._drcpEnabled = false;
     this.serviceName = '';
     this.remoteAddress = '';
     this.comboKey = null; // used in changePassword API
@@ -503,11 +526,21 @@ class ThinConnectionImpl extends ConnectionImpl {
     finalizationRegistry.register(this, this.nscon);
     await this.nscon.connect(params);
 
-    this._connInfo = (this.isPooled()) ? params._connInfo.map((x) => x) :
-      await getConnectionInfo(params);
-    this._drcpEnabled = String(this._connInfo[0]).toLowerCase() === 'pooled';
-    this.serviceName = this._connInfo[2];
-    this.purity = this._connInfo[3] | constants.PURITY_DEFAULT;
+    let serverType;
+    if (this.isPooled()) {
+      serverType = params._connInfo[0];
+      this.serviceName = params._connInfo[2];
+      this.purity = params._connInfo[3] | constants.PURITY_DEFAULT;
+      this.sid = params._connInfo[4];
+    } else {
+      serverType = this.nscon.getOption(sqlNetConstants.SERVERTYPE);
+      this.serviceName = this.nscon.getOption(sqlNetConstants.SVCNAME);
+      this.sid = this.nscon.getOption(sqlNetConstants.SID);
+      this.purity = this.nscon.getOption(sqlNetConstants.PURITY) | constants.PURITY_DEFAULT;
+    }
+    if (serverType) {
+      this._drcpEnabled = serverType.toLowerCase() === 'pooled';
+    }
     this.remoteAddress = this.nscon.getOption(sqlNetConstants.REMOTEADDR);
     this.connectionClass = params.connectionClass;
 
@@ -533,15 +566,40 @@ class ThinConnectionImpl extends ConnectionImpl {
     }
 
     try {
-      let message = new messages.ProtocolMessage(this);
-      await this._protocol._processMessage(message);
-      message = new messages.DataTypeMessage(this);
-      await this._protocol._processMessage(message);
-      message = new messages.AuthMessage(this, params);
-      // Does OSESSKEY for non-token Authentication else OAUTH
-      await this._protocol._processMessage(message);
+      const cookie = this.getConnectionCookieByUUID(this.nscon.dbUUID);
+      this.nscon.dbUUID = null;
+      const protocolMessage = new messages.ProtocolMessage(this);
+      const dataTypeMessage = new messages.DataTypeMessage(this);
+      const authMessage = new messages.AuthMessage(this, params);
+      let sentCookie = false;
+      if (cookie && cookie.populated) {
+        const cookieMessage = new messages.ConnectionCookieMessage(this);
+        cookieMessage.cookie = cookie;
+        cookieMessage.protocolMessage = protocolMessage;
+        cookieMessage.dataTypeMessage = dataTypeMessage;
+        cookieMessage.authMessage = authMessage;
+        await this._protocol._processMessage(cookieMessage);
+        sentCookie = true;
+      } else {
+        await this._protocol._processMessage(protocolMessage);
+      }
+      if (!sentCookie || !cookie.populated) {
+        await this._protocol._processMessage(dataTypeMessage);
+        // Does OSESSKEY for non-token Authentication else OAUTH
+        await this._protocol._processMessage(authMessage);
+        if (cookie && !cookie.populated) {
+          cookie.protocolVersion = protocolMessage.serverVersion;
+          cookie.serverBanner = protocolMessage.serverBanner;
+          cookie.charsetID = this._protocol.caps.charSetID;
+          cookie.ncharsetID = this._protocol.caps.nCharsetId;
+          cookie.flags = protocolMessage.serverFlags;
+          cookie.compileCaps = Buffer.from(protocolMessage.serverCompileCaps);
+          cookie.runtimeCaps = Buffer.from(protocolMessage.serverRunTimeCaps);
+          cookie.populated = true;
+        }
+      }
       if (!params.token) { // non-token Authentication
-        await this._protocol._processMessage(message); // OAUTH
+        await this._protocol._processMessage(authMessage); // OAUTH
       }
     } catch (err) {
       this.nscon.disconnect();

lib/thin/protocol/buffer.js

@@ -923,6 +923,24 @@ class BaseBuffer {
     }
   }
 
+  //---------------------------------------------------------------------------
+  // writeUB2()
+  //
+  // Writes an unsigned integer (up to 2 bytes in length) in variable length
+  // format to the buffer.
+  //---------------------------------------------------------------------------
+  writeUB2(value) {
+    if (value === 0) {
+      this.writeUInt8(0);
+    } else if (value <= 0xff) {
+      this.writeUInt8(1);
+      this.writeUInt8(value);
+    } else {
+      this.writeUInt8(2);
+      this.writeUInt16BE(value);
+    }
+  }
+
   //---------------------------------------------------------------------------
   // writeUB8()
   //

lib/thin/protocol/constants.js

@@ -425,8 +425,10 @@ module.exports = {
   TNS_MSG_TYPE_FLUSH_OUT_BINDS: 19,
   TNS_MSG_TYPE_BIT_VECTOR: 21,
   TNS_MSG_TYPE_SERVER_SIDE_PIGGYBACK: 23,
-  TNS_MSG_TYPE_IMPLICIT_RESULTSET: 27,
   TNS_MSG_TYPE_ONEWAY_FN: 26,
+  TNS_MSG_TYPE_IMPLICIT_RESULTSET: 27,
+  TNS_MSG_TYPE_RENEGOTIATE: 28,
+  TNS_MSG_TYPE_COOKIE: 30,
 
   // parameter keyword numbers,
   TNS_KEYWORD_NUM_CURRENT_SCHEMA: 168,

lib/thin/protocol/messages/base.js

@@ -200,18 +200,19 @@ class Message {
     if (opcode === constants.TNS_SERVER_PIGGYBACK_LTXID) {
       const num_bytes = buf.readUB4();
       if (num_bytes > 0) {
-        buf.skipBytes(num_bytes);
+        buf.skipBytesChunked();
       }
     } else if ((opcode === constants.TNS_SERVER_PIGGYBACK_QUERY_CACHE_INVALIDATION)
      || (opcode === constants.TNS_SERVER_PIGGYBACK_TRACE_EVENT)) {
       // pass
     } else if (opcode === constants.TNS_SERVER_PIGGYBACK_OS_PID_MTS) {
-      buf.skipUB2();
-      buf.skipBytesChunked();
+      const numDtys = buf.readUB2();
+      buf.skipUB1();
+      buf.skipBytes(numDtys);
     } else if (opcode === constants.TNS_SERVER_PIGGYBACK_SYNC) {
       buf.skipUB2();                            // skip number of DTYs
       buf.skipUB1();                            // skip length of DTYs
-      const num_elements = buf.readUB2();
+      const num_elements = buf.readUB4();
       buf.skipBytes(1);                         // skip length
       for (let i = 0; i < num_elements; i++) {
         let temp16 = buf.readUB2();
@@ -223,14 +224,14 @@ class Message {
           buf.skipBytesChunked();
         }
         buf.skipUB2();                          // skip flags
-        buf.skipUB4();                          // skip overall flags
       }
+      buf.skipUB4();                            // skip overall flags
     } else if (opcode === constants.TNS_SERVER_PIGGYBACK_EXT_SYNC) {
       buf.skipUB2();
       buf.skipUB1();
     } else if (opcode === constants.TNS_SERVER_PIGGYBACK_AC_REPLAY_CONTEXT) {
       buf.skipUB2();                            // skip number of DTYs
-      buf.skipUB1(1);                           // skip length of DTYs
+      buf.skipUB1();                            // skip length of DTYs
       buf.skipUB4();                            // skip flags
       buf.skipUB4();                            // skip error code
       buf.skipUB1();                            // skip queue

lib/thin/protocol/messages/connectionCookie.js

@@ -0,0 +1,76 @@
+// Copyright (c) 2023 Oracle and/or its affiliates.
+
+//-----------------------------------------------------------------------------
+//
+// This software is dual-licensed to you under the Universal Permissive License
+// (UPL) 1.0 as shown at https://oss.oracle.com/licenses/upl and Apache License
+// 2.0 as shown at http://www.apache.org/licenses/LICENSE-2.0. You may choose
+// either license.
+//
+// If you elect to accept the software under the Apache License, Version 2.0,
+// the following applies:
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-----------------------------------------------------------------------------
+
+'use strict';
+
+const constants = require("../constants.js");
+const Message = require("./base.js");
+
+/**
+ * Executes a Fast Negotiation RPC function.
+ * It sends Protocol Negotiation, Cookie Message, Datatype Negotiation
+ * and OSESS Key RPC in single round trip.
+ *
+ * @class ConnectionCookieMessage
+ * @extends {Message}
+ */
+class ConnectionCookieMessage extends Message {
+
+  /**
+   * Serializes the ConnectionCookieMessage function arguments
+   *
+   * @param {object} buf input arguments
+   */
+  encode(buf) {
+    this.protocolMessage.encode(buf);
+    buf.writeUInt8(constants.TNS_MSG_TYPE_COOKIE);
+    buf.writeUInt8(1);                  // cookie version
+    buf.writeUInt8(this.cookie.protocolVersion);
+    buf.writeUInt16LE(this.cookie.charsetID);
+    buf.writeUInt8(this.cookie.flags);
+    buf.writeUInt16LE(this.cookie.ncharsetID);
+    buf.writeBytesWithLength(this.cookie.serverBanner);
+    buf.writeBytesWithLength(this.cookie.compileCaps);
+    buf.writeBytesWithLength(this.cookie.runtimeCaps);
+    this.dataTypeMessage.encode(buf);
+    this.authMessage.encode(buf);
+  }
+
+  processMessage(buf, messageType) {
+    if (messageType === constants.TNS_MSG_TYPE_RENEGOTIATE) {
+      this.cookie.populated = false;
+    } else if (messageType === constants.TNS_MSG_TYPE_PROTOCOL) {
+      this.protocolMessage.processMessage(buf, messageType);
+    } else if (messageType === constants.TNS_MSG_TYPE_DATA_TYPES) {
+      this.dataTypeMessage.processMessage(buf, messageType);
+    } else {
+      this.authMessage.processMessage(buf, messageType);
+    }
+  }
+
+}
+
+module.exports = ConnectionCookieMessage;

lib/thin/protocol/messages/dataType.js

@@ -38,14 +38,18 @@ const Message = require("./base.js");
  */
 class DataTypeMessage extends Message {
 
-  processMessage(buf) {
-    while (true) {        // eslint-disable-line
-      const dataType = buf.readUInt16BE();
-      if (dataType === 0)
-        break;
-      const convDataType = buf.readUInt16BE();
-      if (convDataType !== 0)
-        buf.skipBytes(4);
+  processMessage(buf, messageType) {
+    if (messageType === constants.TNS_MSG_TYPE_DATA_TYPES) {
+      while (true) {        // eslint-disable-line
+        const dataType = buf.readUInt16BE();
+        if (dataType === 0)
+          break;
+        const convDataType = buf.readUInt16BE();
+        if (convDataType !== 0)
+          buf.skipBytes(4);
+      }
+    } else {
+      super.processMessage(buf, messageType);
     }
   }
 

lib/thin/protocol/messages/index.js

@@ -37,10 +37,12 @@ const PingMessage = require('./ping.js');
 const ProtocolMessage = require('./protocol.js');
 const RollbackMessage = require('./rollback.js');
 const SessionReleaseMessage = require('./sessionRelease.js');
+const ConnectionCookieMessage = require('./connectionCookie.js');
 
 module.exports = {
   AuthMessage,
   CommitMessage,
+  ConnectionCookieMessage,
   DataTypeMessage,
   ExecuteMessage,
   FetchMessage,

lib/thin/protocol/messages/protocol.js

@@ -50,26 +50,35 @@ class ProtocolMessage extends Message {
     buf.writeUInt8(0);
   }
 
-  decode(buf) {
-    const message_type = buf.readUInt8();
-    if (message_type === constants.TNS_MSG_TYPE_PROTOCOL) {
-      buf.skipBytes(2);                         // skip protocol array
-      let x = buf.readUInt8();
-      while (x !== 0) {                         // skip server banner
-        x = buf.readUInt8();
-      }
-      buf.skipBytes(2);                         // character set ID
-      buf.skipUB1(1);                           // skip server flags
-      const num_elem = buf.readUInt16LE();
-      if (num_elem > 0) {                       // skip elements
-        buf.skipBytes(num_elem * 5);
-      }
-      const fdoLen = buf.readUInt16BE();
-      const fdo = buf.readBytes(fdoLen);
-      const ix = 6 + fdo[5] + fdo[6];
-      buf.caps.nCharsetId = (fdo[ix + 3] << 8) + fdo[ix + 4];
-      buf.caps.adjustForServerCompileCaps(buf.readBytesWithLength());
-      buf.caps.adjustForServerRuntimeCaps(buf.readBytesWithLength());
+  processMessage(buf, messageType) {
+    if (messageType === constants.TNS_MSG_TYPE_PROTOCOL) {
+      this.processProtocolInfo(buf);
+    } else {
+      super.processMessage(buf, messageType);
+    }
+  }
+
+  processProtocolInfo(buf) {
+    this.serverVersion = buf.readUInt8();
+    buf.skipUB1();
+    this.serverBanner = buf.readNullTerminatedBytes(48);
+    buf.caps.charSetID = buf.readUInt16LE();
+    this.serverFlags = buf.readUInt8();
+    const num_elem = buf.readUInt16LE();
+    if (num_elem > 0) {                       // skip elements
+      buf.skipBytes(num_elem * 5);
+    }
+    const fdoLen = buf.readUInt16BE();
+    const fdo = buf.readBytes(fdoLen);
+    const ix = 6 + fdo[5] + fdo[6];
+    buf.caps.nCharsetId = (fdo[ix + 3] << 8) + fdo[ix + 4];
+    this.serverCompileCaps = Buffer.from(buf.readBytesWithLength());
+    if (this.serverCompileCaps) {
+      buf.caps.adjustForServerCompileCaps(this.serverCompileCaps);
+    }
+    this.serverRunTimeCaps = Buffer.from(buf.readBytesWithLength());
+    if (this.serverRunTimeCaps) {
+      buf.caps.adjustForServerRuntimeCaps(this.serverRunTimeCaps);
     }
   }