Give error and prevent releasing the connection when a database call is in progress, thus prevent crashes

Author: Christopher Jones

src/njs/src/njsConnection.cpp

@@ -104,9 +104,12 @@ Connection::~Connection()
 */
 void Connection::setConnection(dpi::Conn* dpiconn, Oracledb* oracledb)
 {
-   this->dpiconn_  = dpiconn;
-   this->isValid_  = true;
-   this->oracledb_ = oracledb;
+   this->dpiconn_   = dpiconn;
+   this->isValid_   = true;
+   this->oracledb_  = oracledb;
+   this->lobCount_  = 0;
+   this->rsCount_   = 0;
+   this->dbCount_   = 0;
 }
 
 /*****************************************************************************/
@@ -438,11 +441,10 @@ NAN_METHOD(Connection::Execute)
   Connection *connection;
   NJS_GET_CALLBACK ( callback, info );
 
-  eBaton *executeBaton = new eBaton;
-  executeBaton->cb.Reset( callback );
-  NJS_CHECK_NUMBER_OF_ARGS ( executeBaton->error, info, 2, 4, exitExecute );
   connection = Nan::ObjectWrap::Unwrap<Connection>(info.This());
+  eBaton *executeBaton = new eBaton ( connection->DBCount (), callback );
 
+  NJS_CHECK_NUMBER_OF_ARGS ( executeBaton->error, info, 2, 4, exitExecute );
   NJS_CHECK_OBJECT_VALID3( connection, executeBaton->error, exitExecute );
 
   if(!connection->isValid_)
@@ -479,8 +481,16 @@ NAN_METHOD(Connection::Execute)
 
   exitExecute:
   executeBaton->req.data  = (void*) executeBaton;
-  uv_queue_work(uv_default_loop(), &executeBaton->req,
+  int status = uv_queue_work(uv_default_loop(), &executeBaton->req,
                Async_Execute, (uv_after_work_cb)Async_AfterExecute);
+  // delete the Baton if uv_queue_work fails
+  if ( status )
+  {
+    delete executeBaton;
+    string error = NJSMessages::getErrorMsg ( errInternalError,
+                                              "uv_queue_work", "Execute" );
+    NJS_SET_EXCEPTION(error.c_str(), error.length());
+  }
 
   info.GetReturnValue().SetUndefined();
 }
@@ -2053,9 +2063,8 @@ void Connection::Async_AfterExecute(uv_work_t *req)
     }
     argv[1] = result;
   }
-  exitAsyncAfterExecute:
+exitAsyncAfterExecute:
   Local<Function> callback = Nan::New<Function>(executeBaton->cb);
-  executeBaton->cb.Reset ();
   delete executeBaton;
   Nan::MakeCallback( Nan::GetCurrentContext()->Global(), callback, 2, argv );
   if(tc.HasCaught())
@@ -2546,6 +2555,33 @@ v8::Local<v8::Value> Connection::GetOutBindObject ( eBaton *executeBaton )
   return scope.Escape(objectBinds);
 }
 
+
+/****************************************************************************/
+/* NAME
+ *   Connection::getConnectionBusyStatus
+ *
+ * DESCRIPTION
+ *   Checks whther connection is busy with database call or not using counters
+ *
+ * PARAMETERS
+ *   connection      - connection object to check it's counters
+ *
+ * Note: Currently this function can be used only in Release () method
+ */
+ConnectionBusyStatus Connection::getConnectionBusyStatus ( Connection *conn )
+{
+  ConnectionBusyStatus connStatus = CONN_NOT_BUSY;
+
+  if ( conn->lobCount_ != 0 )
+    connStatus = CONN_BUSY_LOB;
+  else if ( conn->rsCount_ != 0 )
+    connStatus = CONN_BUSY_RS;
+  else if ( conn->dbCount_ != 1 ) // 1 for Release operaion itself
+    connStatus = CONN_BUSY_DB;
+
+  return connStatus;
+}
+
 /*****************************************************************************/
 /*
    DESCRIPTION
@@ -2560,26 +2596,55 @@ NAN_METHOD(Connection::Release)
   Local<Function> callback;
   Connection *connection;
   NJS_GET_CALLBACK ( callback, info );
+  ConnectionBusyStatus connStat;
 
-  eBaton* releaseBaton = new eBaton;
-  releaseBaton->cb.Reset(callback);
-  
-  NJS_CHECK_NUMBER_OF_ARGS ( releaseBaton->error, info, 1, 1, exitRelease );
   connection = Nan::ObjectWrap::Unwrap<Connection>(info.This());
+  eBaton *releaseBaton = new eBaton ( connection->DBCount (), callback );
 
+  NJS_CHECK_NUMBER_OF_ARGS ( releaseBaton->error, info, 1, 1, exitRelease );
   NJS_CHECK_OBJECT_VALID3(connection, releaseBaton->error, exitRelease);
   if(!connection->isValid_)
   {
     releaseBaton->error = NJSMessages::getErrorMsg ( errInvalidConnection );
     goto exitRelease;
   }
+
+
+  // Check to see if database call is in progress
+  connStat = getConnectionBusyStatus ( connection );
+  switch ( connStat )
+  {
+    case CONN_NOT_BUSY:
+      break;    // Nothing to do in this case
+    case CONN_BUSY_LOB:
+      releaseBaton->error = NJSMessages::getErrorMsg( errBusyConnLOB );
+      goto exitRelease;
+    case CONN_BUSY_RS:
+      releaseBaton->error = NJSMessages::getErrorMsg( errBusyConnRS );
+      goto exitRelease;
+    case CONN_BUSY_DB:
+      releaseBaton->error = NJSMessages::getErrorMsg( errBusyConnDB );
+      goto exitRelease;
+  
+    default:
+      break;
+  }
+
   connection->isValid_    = false;
   releaseBaton->dpiconn   = connection->dpiconn_;
   exitRelease:
   releaseBaton->req.data  = (void*) releaseBaton;
 
-  uv_queue_work(uv_default_loop(), &releaseBaton->req,
+  int status = uv_queue_work(uv_default_loop(), &releaseBaton->req,
                Async_Release, (uv_after_work_cb)Async_AfterRelease);
+  // delete the Baton if uv_queue_work fails
+  if ( status )
+  {
+    delete releaseBaton;
+    string error = NJSMessages::getErrorMsg ( errInternalError,
+                                              "uv_queue_work", "Release" );
+    NJS_SET_EXCEPTION(error.c_str(), error.length());
+  }
   info.GetReturnValue().SetUndefined();
   scope.Escape ( Nan::Undefined () );
 }
@@ -2635,7 +2700,6 @@ void Connection::Async_AfterRelease(uv_work_t *req)
   else
     argv[0] = Nan::Undefined();
   Local<Function> callback = Nan::New<Function>(releaseBaton->cb);
-  releaseBaton->cb.Reset ();
   delete releaseBaton;
   Nan::MakeCallback( Nan::GetCurrentContext()->Global(),
                       callback, 1, argv );
@@ -2660,11 +2724,10 @@ NAN_METHOD(Connection::Commit)
   Connection *connection;
   NJS_GET_CALLBACK ( callback, info );
 
-  eBaton* commitBaton = new eBaton;
-  commitBaton->cb.Reset( callback );
-  NJS_CHECK_NUMBER_OF_ARGS ( commitBaton->error, info, 1, 1, exitCommit );
   connection = Nan::ObjectWrap::Unwrap<Connection>(info.This());
+  eBaton *commitBaton = new eBaton ( connection->DBCount (), callback );
 
+  NJS_CHECK_NUMBER_OF_ARGS ( commitBaton->error, info, 1, 1, exitCommit );
   NJS_CHECK_OBJECT_VALID3 ( connection, commitBaton->error, exitCommit );
   if(!connection->isValid_)
   {
@@ -2675,8 +2738,16 @@ NAN_METHOD(Connection::Commit)
 exitCommit:
   commitBaton->req.data  = (void*) commitBaton;
 
-  uv_queue_work(uv_default_loop(), &commitBaton->req,
+  int status = uv_queue_work(uv_default_loop(), &commitBaton->req,
                Async_Commit, (uv_after_work_cb)Async_AfterCommit);
+  // delete the Baton if uv_queue_work fails
+  if ( status )
+  {
+    delete commitBaton;
+    string error = NJSMessages::getErrorMsg ( errInternalError,
+                                              "uv_queue_work", "Commit" );
+    NJS_SET_EXCEPTION(error.c_str(), error.length());
+  }
 
   info.GetReturnValue().SetUndefined();
 }
@@ -2732,14 +2803,15 @@ void Connection::Async_AfterCommit (uv_work_t *req)
   else
     argv[0] = Nan::Undefined();
 
+  Local<Function> callback = Nan::New<Function>(commitBaton->cb);
+  delete commitBaton;
   Nan::MakeCallback( Nan::GetCurrentContext()->Global(),
-                      Nan::New<Function>(commitBaton->cb), 1, argv );
+                      callback, 1, argv );
+
   if(tc.HasCaught())
   {
     Nan::FatalException(tc);
   }
-  commitBaton->cb.Reset ();
-  delete commitBaton;
 }
 
 /*****************************************************************************/
@@ -2756,10 +2828,9 @@ NAN_METHOD(Connection::Rollback)
   Connection *connection;
   NJS_GET_CALLBACK ( callback, info );
 
-  eBaton* rollbackBaton = new eBaton;
-  rollbackBaton->cb.Reset( callback );
-  NJS_CHECK_NUMBER_OF_ARGS ( rollbackBaton->error, info, 1, 1, exitRollback );
   connection = Nan::ObjectWrap::Unwrap<Connection>(info.This());
+  eBaton *rollbackBaton = new eBaton ( connection->DBCount (), callback );
+  NJS_CHECK_NUMBER_OF_ARGS ( rollbackBaton->error, info, 1, 1, exitRollback );
   NJS_CHECK_OBJECT_VALID3 ( connection, rollbackBaton->error, exitRollback );
 
   if(!connection->isValid_)
@@ -2770,8 +2841,16 @@ NAN_METHOD(Connection::Rollback)
   rollbackBaton->dpiconn   = connection->dpiconn_;
   exitRollback:
   rollbackBaton->req.data  = (void*) rollbackBaton;
-  uv_queue_work(uv_default_loop(), &rollbackBaton->req,
-                Async_Rollback, (uv_after_work_cb)Async_AfterRollback);
+  int status = uv_queue_work(uv_default_loop(), &rollbackBaton->req,
+               Async_Rollback, (uv_after_work_cb)Async_AfterRollback);
+  // delete the Baton if uv_queue_work fails
+  if ( status )
+  {
+    delete rollbackBaton;
+    string error = NJSMessages::getErrorMsg ( errInternalError,
+                                              "uv_queue_work", "Rollback" );
+    NJS_SET_EXCEPTION(error.c_str(), error.length());
+  }
   info.GetReturnValue().SetUndefined();
 }
 
@@ -2826,14 +2905,14 @@ void Connection::Async_AfterRollback(uv_work_t *req)
   else
     argv[0] = Nan::Undefined();
 
+  Local<Function> callback = Nan::New<Function>(rollbackBaton->cb);
+  delete rollbackBaton;
   Nan::MakeCallback( Nan::GetCurrentContext()->Global(),
-                      Nan::New<Function>(rollbackBaton->cb), 1, argv );
+                      callback, 1, argv );
   if(tc.HasCaught())
   {
     Nan::FatalException(tc);
   }
-  rollbackBaton->cb.Reset ();
-  delete rollbackBaton;
 }
 
 /*****************************************************************************/
@@ -2850,11 +2929,10 @@ NAN_METHOD(Connection::Break)
   Connection *connection;
   NJS_GET_CALLBACK ( callback, info );
 
-  eBaton* breakBaton = new eBaton;
-  breakBaton->cb.Reset( callback );
-  NJS_CHECK_NUMBER_OF_ARGS ( breakBaton->error, info, 1, 1, exitBreak );
   connection = Nan::ObjectWrap::Unwrap<Connection>(info.This());
+  eBaton *breakBaton = new eBaton ( connection->DBCount (), callback );
 
+  NJS_CHECK_NUMBER_OF_ARGS ( breakBaton->error, info, 1, 1, exitBreak );
   NJS_CHECK_OBJECT_VALID3 ( connection, breakBaton->error, exitBreak );
 
   if(!connection->isValid_)
@@ -2866,8 +2944,16 @@ NAN_METHOD(Connection::Break)
   exitBreak:
   breakBaton->req.data  = (void*) breakBaton;
 
-  uv_queue_work(uv_default_loop(), &breakBaton->req,
+  int status = uv_queue_work(uv_default_loop(), &breakBaton->req,
                Async_Break, (uv_after_work_cb)Async_AfterBreak);
+  // delete the Baton if uv_queue_work fails
+  if ( status )
+  {
+    delete breakBaton;
+    string error = NJSMessages::getErrorMsg ( errInternalError,
+                                              "uv_queue_work", "Break" );
+    NJS_SET_EXCEPTION(error.c_str(), error.length());
+  }
 
   info.GetReturnValue().SetUndefined();
 }
@@ -2923,14 +3009,14 @@ void Connection::Async_AfterBreak (uv_work_t *req)
     argv[0] = v8::Exception::Error(Nan::New<v8::String>((breakBaton->error).c_str()).ToLocalChecked());
   else
     argv[0] = Nan::Undefined();
+  Local<Function> callback = Nan::New<Function>(breakBaton->cb);
+  delete breakBaton;
   Nan::MakeCallback( Nan::GetCurrentContext()->Global(),
-                      Nan::New<Function>(breakBaton->cb), 1, argv );
+                      callback, 1, argv );
   if(tc.HasCaught())
   {
     Nan::FatalException(tc);
   }
-  breakBaton->cb.Reset ();
-  delete breakBaton;
 }
 
 /****************************************************************************/

src/njs/src/njsConnection.h

@@ -58,7 +58,6 @@
 #include "njsUtils.h"
 #include "njsOracle.h"
 
-
 using namespace v8;
 using namespace node;
 using namespace dpi;
@@ -159,19 +158,24 @@ typedef struct eBaton
   unsigned int         fetchInfoCount;   // Conversion requested count
   FetchInfo            *fetchInfo;       // Conversion meta data
   Nan::Persistent<Function> cb;
+  RefCounter                counter;
 
-  eBaton() : sql(""), error(""), dpienv(NULL), dpiconn(NULL), njsconn(NULL),
+  eBaton( unsigned int& count, Local<Function> callback ) :
+             sql(""), error(""), dpienv(NULL), dpiconn(NULL), njsconn(NULL),
              rowsAffected(0), maxRows(0), prefetchRows(0),
              getRS(false), autoCommit(false), rowsFetched(0), 
              outFormat(0), numCols(0), dpistmt(NULL),
              st(DpiStmtUnknown), stmtIsReturning (false), numOutBinds(0),
              columnNames(NULL), defines(NULL), fetchAsStringTypesCount (0),
-             fetchAsStringTypes(NULL), fetchInfoCount(0), fetchInfo(NULL)
-  {}
+             fetchAsStringTypes(NULL), fetchInfoCount(0), fetchInfo(NULL),
+             counter ( count )
+  { 
+    cb.Reset( callback );
+  }
 
   ~eBaton ()
    {
-     //NanDisposePersistent(cb);
+     cb.Reset ();
      if( !binds.empty() )
      {
        for( unsigned int index = 0 ;index < binds.size(); index++ )
@@ -258,6 +262,16 @@ class Connection: public Nan::ObjectWrap
   static void CopyMetaData ( std::string*, const dpi::MetaData*, unsigned int ); 
   bool isValid() { return isValid_; }
   dpi::Conn* getDpiConn() { return dpiconn_; }
+
+  /*
+   * Counters to see whether connection is busy or not with LOB, ResultSet or
+   * DB operations. This counters incremented and decremented for each
+   * operation and used to prevent releasing busy connection.
+   */
+  inline unsigned int& LOBCount ()   { return lobCount_; }
+  inline unsigned int& RSCount  ()   { return rsCount_;  }
+  inline unsigned int& DBCount  ()   { return dbCount_;  }
+
   Oracledb* oracledb_;
 
 private:
@@ -367,6 +381,7 @@ class Connection: public Nan::ObjectWrap
   //static void UpdateDateValue ( eBaton *executeBaton );
   static void UpdateDateValue ( eBaton *executeBaton, unsigned int index );
   static void v8Date2OraDate ( v8::Local<v8::Value>, Bind *bind);
+  static ConnectionBusyStatus getConnectionBusyStatus ( Connection *conn );
 
   // Callback/Utility function used to allocate buffer(s) for Bind Structs
   static void cbDynBufferAllocate ( void *ctx, bool dmlReturning,
@@ -396,6 +411,13 @@ class Connection: public Nan::ObjectWrap
   dpi::Conn*     dpiconn_;
   bool           isValid_;
   unsigned int   oracleServerVersion_;
+  /*
+   * Counters to see whether connection is busy or not with LOB, ResultSet or
+   * DB operations. This counters used to prevent releasing busy connection.
+   */
+  unsigned int   lobCount_;    // LOB operations counter
+  unsigned int   rsCount_;     // ResultSet operations counter
+  unsigned int   dbCount_;     // Connection or DB operations counter
 
 };