Internal code improvements

Author: sharadraju

lib/connection.js

@@ -1584,9 +1584,9 @@ class Connection extends EventEmitter {
 // that cannot take place concurrently
 // NOTE: breakExecution() should not be serialized
 Connection.prototype.break =
-    nodbUtil.callbackify(Connection.prototype.breakExecution);
+    nodbUtil.callbackify(nodbUtil.wrapFn(Connection.prototype.breakExecution));
 Connection.prototype.tpcRecover =
-    nodbUtil.callbackify(Connection.prototype.tpcRecover);
+    nodbUtil.callbackify(nodbUtil.wrapFn(Connection.prototype.tpcRecover));
 nodbUtil.wrapFns(Connection.prototype,
   "changePassword",
   "close",

lib/lob.js

@@ -300,7 +300,8 @@ nodbUtil.wrapFns(Lob.prototype, errors.ERR_BUSY_LOB,
   "close",
   "fileExists",
   "getData");
-Lob.prototype._serializedRead = nodbUtil.serialize(Lob.prototype._readData);
-Lob.prototype._serializedWrite = nodbUtil.serialize(Lob.prototype._writeData);
+Lob.prototype._serializedRead = nodbUtil.wrapFn(Lob.prototype._readData, true);
+Lob.prototype._serializedWrite =
+  nodbUtil.wrapFn(Lob.prototype._writeData, true);
 
 module.exports = Lob;

lib/oracledb.js

@@ -879,12 +879,12 @@ module.exports = {
   SodaOperation,
 
   // top-level functions
-  getConnection: nodbUtil.callbackify(getConnection),
-  createPool: nodbUtil.callbackify(createPool),
+  getConnection: nodbUtil.callbackify(nodbUtil.wrapFn(getConnection)),
+  createPool: nodbUtil.callbackify(nodbUtil.wrapFn(createPool)),
   getPool,
   initOracleClient,
-  shutdown: nodbUtil.callbackify(shutdown),
-  startup: nodbUtil.callbackify(startup),
+  shutdown: nodbUtil.callbackify(nodbUtil.wrapFn(shutdown)),
+  startup: nodbUtil.callbackify(nodbUtil.wrapFn(startup)),
 
   // CQN operation codes
   CQN_OPCODE_ALL_OPS: constants.CQN_OPCODE_ALL_OPS,

lib/pool.js

@@ -800,10 +800,11 @@ class Pool extends EventEmitter {
 
 }
 
-Pool.prototype.close = nodbUtil.callbackify(Pool.prototype.close);
-Pool.prototype.getConnection = nodbUtil.callbackify(Pool.prototype.getConnection);
-Pool.prototype.reconfigure = nodbUtil.callbackify(Pool.prototype.reconfigure);
-Pool.prototype.setAccessToken = nodbUtil.callbackify(Pool.prototype.setAccessToken);
+nodbUtil.wrapFns(Pool.prototype, false,
+  "close",
+  "getConnection",
+  "reconfigure",
+  "setAccessToken");
 
 // DEPRECATED aliases
 Pool.prototype.terminate = Pool.prototype.close;

lib/util.js

@@ -124,37 +124,41 @@ function callbackify(func) {
     // if last argument is not a function, simply invoke the function as usual
     // and a promise will be returned
     if (typeof arguments[arguments.length - 1] !== 'function') {
-      return func.apply(this, arguments).catch(function stackCapture(err) {
-        throw errors.transformErr(err, stackCapture);
-      });
+      return func.apply(this, arguments);
     }
 
     // otherwise, resolve or reject the promise and invoke the callback
     const args = Array.prototype.slice.call(arguments, 0, arguments.length - 1);
     const cb = arguments[arguments.length - 1];
     func.apply(this, args).then(function(result) {
       cb(null, result);
-    }, function stackCapture(err) {
-      cb(errors.transformErr(err, stackCapture));
-    });
+    }, cb);
   };
   if (func.name) {
     Object.defineProperty(wrapper, 'name', { value: func.name });
   }
   return wrapper;
 }
 
-// The serialize function is used to wrap methods to ensure that the connection
-// is not used concurrently by multiple threads
-function serialize(func) {
-  return async function() {
+// the wrapFn() function is used to wrap a single method to ensure that calls
+// are serialized and that concurrent calls are prevented where that is needed;
+// this method also ensures that error information is captured correctly
+function wrapFn(func, serialize, preventConcurrentErrorCode) {
+  const wrapper = async function wrapper() {
 
     let connImpl;
 
+    // if concurrent operations are to be prevented, check for that now
+    if (preventConcurrentErrorCode) {
+      if (this._isActive)
+        errors.throwErr(preventConcurrentErrorCode);
+      this._isActive = true;
+    }
+
     // determine the connection implementation associated with the object, if
     // one currently exists and acquire the "lock"; this simply checks to see
     // if another operation is in progress, and if so, waits for it to complete
-    if (this._impl) {
+    if (serialize && this._impl) {
       connImpl = this._impl._getConnImpl();
       await connImpl._acquireLock();
     }
@@ -164,46 +168,43 @@ function serialize(func) {
     // if a connection implementation is currently associated with this object
     try {
       return await func.apply(this, arguments);
+    } catch (err) {
+      throw errors.transformErr(err, wrapper);
     } finally {
       if (connImpl)
         connImpl._releaseLock();
+      if (preventConcurrentErrorCode) {
+        this._isActive = false;
+      }
     }
-  };
-}
 
-function preventConcurrent(func, errorCode) {
-  return async function() {
-    if (this._isActive)
-      errors.throwErr(errorCode);
-    this._isActive = true;
-    try {
-      return await func.apply(this, arguments);
-    } finally {
-      this._isActive = false;
-    }
   };
+  if (func.name) {
+    Object.defineProperty(wrapper, 'name', { value: func.name });
+  }
+  return wrapper;
 }
 
 // The wrapFns() function is used to wrap the named methods on the prototype
-// in multiple ways (serialize, preventConcurrent and callbackify); the
+// so that a number of common tasks can be done in a single place; the
 // arguments following the formal arguments contain the names of methods to
 // wrap on the prototype; if the first extra argument is an error code, it is
 // used to wrap to prevent concurrent access
 function wrapFns(proto) {
   let nameIndex = 1;
+  let serialize = true;
   let preventConcurrentErrorCode;
   if (typeof arguments[1] === 'number') {
-    nameIndex = 2;
+    nameIndex++;
     preventConcurrentErrorCode = arguments[1];
+  } else if (typeof arguments[1] === 'boolean') {
+    nameIndex++;
+    serialize = arguments[1];
   }
   for (let i = nameIndex; i < arguments.length; i++) {
     const name = arguments[i];
     const f = proto[name];
-    if (preventConcurrentErrorCode) {
-      proto[name] = callbackify(preventConcurrent(serialize(f),
-        preventConcurrentErrorCode));
-    } else
-      proto[name] = callbackify(serialize(f));
+    proto[name] = callbackify(wrapFn(f, serialize, preventConcurrentErrorCode));
   }
 }
 
@@ -436,8 +437,7 @@ module.exports = {
   isXid,
   normalizeXid,
   makeDate,
-  preventConcurrent,
-  serialize,
   verifySodaDoc,
+  wrapFn,
   wrapFns
 };