bk commit into 5.1 tree (jonas:1.2586) BUG#34853

[jonas]

Below is the list of changes that have just been committed into a local
5.1 repository of jonas.  When jonas does a push these changes
will be propagated to the main repository and, within 24 hours after the
push, to the public repository.
For information on how to access the public repository
see http://dev.mysql.com/doc/mysql/en/installing-source-tree.html

ChangeSet@stripped, 2008-04-25 11:17:15+02:00, jonas@stripped +8 -0
  ndb - bug#34853 (port from drop6)
    Fix rare race-condition causing connections to be blocked

  storage/ndb/src/common/transporter/TransporterRegistry.cpp@stripped, 2008-04-25
11:17:13+02:00, jonas@stripped +7 -2
    Check return code of connect_server
    And check performState once more
      
    No verifyable test...only code review

  storage/ndb/src/kernel/blocks/cmvmi/Cmvmi.cpp@stripped, 2008-04-25 11:17:13+02:00,
jonas@stripped +48 -61
    Move *all* control over connections from CMVMI (which partially handled MGM + open
connection in SP8)

  storage/ndb/src/kernel/blocks/ndbcntr/Ndbcntr.hpp@stripped, 2008-04-25 11:17:13+02:00,
jonas@stripped +5 -0
    Add error insert for block in certain sp

  storage/ndb/src/kernel/blocks/ndbcntr/NdbcntrMain.cpp@stripped, 2008-04-25 11:17:13+02:00,
jonas@stripped +35 -0
    Add error insert for block in certain sp

  storage/ndb/src/kernel/blocks/qmgr/Qmgr.hpp@stripped, 2008-04-25 11:17:13+02:00,
jonas@stripped +1 -0
    new variable to control when API's can connect

  storage/ndb/src/kernel/blocks/qmgr/QmgrMain.cpp@stripped, 2008-04-25 11:17:13+02:00,
jonas@stripped +76 -10
    Move *all* control over connections from CMVMI (which partially handled MGM + open
connection in SP8)

  storage/ndb/test/ndbapi/test_event.cpp@stripped, 2008-04-25 11:17:13+02:00,
jonas@stripped +182 -0
    testcase for bug#34853

  storage/ndb/test/run-test/daily-basic-tests.txt@stripped, 2008-04-25 11:17:13+02:00,
jonas@stripped +4 -0
    testcase for bug#34853

diff -Nrup a/storage/ndb/src/common/transporter/TransporterRegistry.cpp
b/storage/ndb/src/common/transporter/TransporterRegistry.cpp
--- a/storage/ndb/src/common/transporter/TransporterRegistry.cpp	2008-04-22 21:36:00
+02:00
+++ b/storage/ndb/src/common/transporter/TransporterRegistry.cpp	2008-04-25 11:17:13
+02:00
@@ -262,9 +262,14 @@ TransporterRegistry::connect_server(NDB_
   }
 
   // setup transporter (transporter responsible for closing sockfd)
-  t->connect_server(sockfd);
+  bool res = t->connect_server(sockfd);
 
-  DBUG_RETURN(true);
+  if (res && performStates[nodeId] != TransporterRegistry::CONNECTING)
+  {
+    DBUG_RETURN(false);
+  }
+
+  DBUG_RETURN(res);
 }
 
 bool
diff -Nrup a/storage/ndb/src/kernel/blocks/cmvmi/Cmvmi.cpp
b/storage/ndb/src/kernel/blocks/cmvmi/Cmvmi.cpp
--- a/storage/ndb/src/kernel/blocks/cmvmi/Cmvmi.cpp	2008-04-22 21:36:00 +02:00
+++ b/storage/ndb/src/kernel/blocks/cmvmi/Cmvmi.cpp	2008-04-25 11:17:13 +02:00
@@ -433,13 +433,24 @@ void Cmvmi::execSTTOR(Signal* signal)
     globalData.activateSendPacked = 1;
     sendSTTORRY(signal);
   } else if (theStartPhase == 8){
-    /*---------------------------------------------------*/
-    /* Open com to API + REP nodes                       */
-    /*---------------------------------------------------*/
-    signal->theData[0] = 0; // no answer
-    signal->theData[1] = 0; // no id
-    signal->theData[2] = NodeInfo::API;
-    execOPEN_COMREQ(signal);
+    if (ERROR_INSERTED(9004))
+    {
+      Uint32 len = signal->getLength();
+      Uint32 db = c_dbNodes.find(0);
+      if (db == getOwnNodeId())
+        db = c_dbNodes.find(db);
+      Uint32 i = c_error_9000_nodes_mask.find(0);
+      Uint32 tmp[25];
+      memcpy(tmp, signal->theData, sizeof(tmp));
+      signal->theData[0] = i;
+      sendSignal(calcQmgrBlockRef(db),GSN_API_FAILREQ, signal, 1, JBA);
+      ndbout_c("stopping %u using %u", i, db);
+      CLEAR_ERROR_INSERT_VALUE;
+      memcpy(signal->theData, tmp, sizeof(tmp));
+      sendSignalWithDelay(reference(), GSN_STTOR,
+                          signal, 100, len);
+      return;
+    }
     globalData.theStartLevel = NodeState::SL_STARTED;
     sendSTTORRY(signal);
   }
@@ -502,14 +513,6 @@ void Cmvmi::execOPEN_COMREQ(Signal* sign
 	   && c_error_9000_nodes_mask.get(tStartingNode)))
 #endif
     {
-      if (globalData.theStartLevel != NodeState::SL_STARTED &&
-          (getNodeInfo(tStartingNode).m_type != NodeInfo::DB &&
-           getNodeInfo(tStartingNode).m_type != NodeInfo::MGM))
-      {
-        jam();
-        goto done;
-      }
-
       globalTransporterRegistry.do_connect(tStartingNode);
       globalTransporterRegistry.setIOState(tStartingNode, HaltIO);
       
@@ -534,7 +537,6 @@ void Cmvmi::execOPEN_COMREQ(Signal* sign
 	    && c_error_9000_nodes_mask.get(i))
 	  continue;
 #endif
-	
 	globalTransporterRegistry.do_connect(i);
 	globalTransporterRegistry.setIOState(i, HaltIO);
 	
@@ -607,38 +609,17 @@ void Cmvmi::execCONNECT_REP(Signal *sign
   globalData.m_nodeInfo[hostId].m_version = 0;
   globalData.m_nodeInfo[hostId].m_mysql_version = 0;
   
-  if(type == NodeInfo::DB || globalData.theStartLevel >= NodeState::SL_STARTED){
-    jam();
-    
-    /**
-     * Inform QMGR that client has connected
-     */
-
-    signal->theData[0] = hostId;
-    sendSignal(QMGR_REF, GSN_CONNECT_REP, signal, 1, JBA);
-  } else if(globalData.theStartLevel == NodeState::SL_CMVMI ||
-            globalData.theStartLevel == NodeState::SL_STARTING) {
-    jam();
-    /**
-     * Someone connected before start was finished
-     */
-    if(type == NodeInfo::MGM){
-      jam();
-      signal->theData[0] = hostId;
-      sendSignal(QMGR_REF, GSN_CONNECT_REP, signal, 1, JBA);
-    } else {
-      /**
-       * Dont allow api nodes to connect
-       */
-      ndbout_c("%d %d %d", hostId, type, globalData.theStartLevel);
-      abort();
-      globalTransporterRegistry.do_disconnect(hostId);
-    }
-  }
+  /**
+   * Inform QMGR that client has connected
+   */
   
+  signal->theData[0] = hostId;
+  sendSignal(QMGR_REF, GSN_CONNECT_REP, signal, 1, JBA);
+
   /* Automatically subscribe events for MGM nodes.
    */
-  if(type == NodeInfo::MGM){
+  if(type == NodeInfo::MGM)
+  {
     jam();
     globalTransporterRegistry.setIOState(hostId, NoHalt);
   }
@@ -827,26 +808,16 @@ Cmvmi::execSTART_ORD(Signal* signal) {
     return;
   }
   
-  if(globalData.theStartLevel == NodeState::SL_NOTHING){
+  if(globalData.theStartLevel == NodeState::SL_NOTHING)
+  {
     jam();
     globalData.theStartLevel = NodeState::SL_CMVMI;
-    /**
-     * Open connections to management servers
-     */
-    for(unsigned int i = 1; i < MAX_NODES; i++ ){
-      if (getNodeInfo(i).m_type == NodeInfo::MGM){ 
-        if(!globalTransporterRegistry.is_connected(i)){
-          globalTransporterRegistry.do_connect(i);
-          globalTransporterRegistry.setIOState(i, NoHalt);
-        }
-      }
-    }
-
     EXECUTE_DIRECT(QMGR, GSN_START_ORD, signal, 1);
     return ;
   }
   
-  if(globalData.theStartLevel == NodeState::SL_CMVMI){
+  if(globalData.theStartLevel == NodeState::SL_CMVMI)
+  {
     jam();
 
     if(m_ctx.m_config.lockPagesInMainMemory() == 2)
@@ -874,8 +845,10 @@ Cmvmi::execSTART_ORD(Signal* signal) {
     // Disconnect all nodes as part of the system restart. 
     // We need to ensure that we are starting up
     // without any connected nodes.   
-    for(unsigned int i = 1; i < MAX_NODES; i++ ){
-      if (i != getOwnNodeId() && getNodeInfo(i).m_type != NodeInfo::MGM){
+    for(unsigned int i = 1; i < MAX_NODES; i++ )
+    {
+      if (i != getOwnNodeId() && getNodeInfo(i).m_type != NodeInfo::MGM)
+      {
         globalTransporterRegistry.do_disconnect(i);
         globalTransporterRegistry.setIOState(i, HaltIO);
       }
@@ -1150,6 +1123,20 @@ Cmvmi::execDUMP_STATE_ORD(Signal* signal
       }
     }
     c_error_9000_nodes_mask.clear();
+  }
+
+  if (arg == 9004 && signal->getLength() == 2)
+  {
+    SET_ERROR_INSERT_VALUE(9004);
+    c_error_9000_nodes_mask.clear();
+    c_error_9000_nodes_mask.set(signal->theData[1]);
+  }
+
+  if (arg == 9004 && signal->getLength() == 2)
+  {
+    SET_ERROR_INSERT_VALUE(9004);
+    c_error_9000_nodes_mask.clear();
+    c_error_9000_nodes_mask.set(signal->theData[1]);
   }
 #endif
 
diff -Nrup a/storage/ndb/src/kernel/blocks/ndbcntr/Ndbcntr.hpp
b/storage/ndb/src/kernel/blocks/ndbcntr/Ndbcntr.hpp
--- a/storage/ndb/src/kernel/blocks/ndbcntr/Ndbcntr.hpp	2007-02-26 08:11:56 +01:00
+++ b/storage/ndb/src/kernel/blocks/ndbcntr/Ndbcntr.hpp	2008-04-25 11:17:13 +02:00
@@ -47,6 +47,7 @@
 //------- OTHERS ---------------------------------------------
 #define ZSTARTUP  1
 #define ZSHUTDOWN 2
+#define ZBLOCK_STTOR 3
 
 #define ZSIZE_NDB_BLOCKS_REC 16 /* MAX BLOCKS IN NDB                    */
 #define ZSIZE_SYSTAB 2048
@@ -382,6 +383,10 @@ private:
   void execREAD_CONFIG_CONF(Signal*);
 
   friend struct UpgradeStartup;
+
+#ifdef ERROR_INSERT
+  Uint32 c_error_insert_extra;
+#endif
 };
 
 #endif
diff -Nrup a/storage/ndb/src/kernel/blocks/ndbcntr/NdbcntrMain.cpp
b/storage/ndb/src/kernel/blocks/ndbcntr/NdbcntrMain.cpp
--- a/storage/ndb/src/kernel/blocks/ndbcntr/NdbcntrMain.cpp	2007-09-13 13:59:44 +02:00
+++ b/storage/ndb/src/kernel/blocks/ndbcntr/NdbcntrMain.cpp	2008-04-25 11:17:13 +02:00
@@ -159,6 +159,18 @@ void Ndbcntr::execCONTINUEB(Signal* sign
     jam();
     c_stopRec.checkTimeout(signal);
     break;
+  case ZBLOCK_STTOR:
+    if (ERROR_INSERTED(1002))
+    {
+      signal->theData[0] = ZBLOCK_STTOR;
+      sendSignalWithDelay(reference(), GSN_CONTINUEB, signal, 100, 1);
+      return;
+    }
+    else
+    {
+      c_missra.sendNextSTTOR(signal);
+    }
+    return;
   default:
     jam();
     systemErrorLab(signal, __LINE__);
@@ -2084,6 +2096,19 @@ Ndbcntr::execDUMP_STATE_ORD(Signal* sign
     return;
   }
 
+  if (arg == 71)
+  {
+    if (signal->getLength() == 2)
+    {
+      c_error_insert_extra = signal->theData[1];
+      SET_ERROR_INSERT_VALUE(1002);
+    }
+    else if (ERROR_INSERTED(1002))
+    {
+      CLEAR_ERROR_INSERT_VALUE;
+    }
+  }
+
 }//Ndbcntr::execDUMP_STATE_ORD()
 
 void Ndbcntr::updateNodeState(Signal* signal, const NodeState& newState) const{
@@ -2880,6 +2905,16 @@ void Ndbcntr::Missra::sendNextSTTOR(Sign
   for(; currentStartPhase < 255 ;
       currentStartPhase++, g_currentStartPhase = currentStartPhase){
     jam();
+
+#ifdef ERROR_INSERT
+    if (cntr.cerrorInsert == 1002 &&
+        cntr.c_error_insert_extra == currentStartPhase)
+    {
+      signal->theData[0] = ZBLOCK_STTOR;
+      cntr.sendSignalWithDelay(cntr.reference(), GSN_CONTINUEB, signal, 100, 1);
+      return;
+    }
+#endif
     
     const Uint32 start = currentBlockIndex;
 
diff -Nrup a/storage/ndb/src/kernel/blocks/qmgr/Qmgr.hpp
b/storage/ndb/src/kernel/blocks/qmgr/Qmgr.hpp
--- a/storage/ndb/src/kernel/blocks/qmgr/Qmgr.hpp	2008-02-20 10:04:24 +01:00
+++ b/storage/ndb/src/kernel/blocks/qmgr/Qmgr.hpp	2008-04-25 11:17:13 +02:00
@@ -421,6 +421,7 @@ private:
   Uint16 cnoPrepFailedNodes;
   Uint16 cnoCommitFailedNodes;
   Uint16 cactivateApiCheck;
+  Uint16 c_allow_api_connect;
   UintR chbApiDelay;
 
   UintR ccommitFailureNr;
diff -Nrup a/storage/ndb/src/kernel/blocks/qmgr/QmgrMain.cpp
b/storage/ndb/src/kernel/blocks/qmgr/QmgrMain.cpp
--- a/storage/ndb/src/kernel/blocks/qmgr/QmgrMain.cpp	2008-04-25 09:11:27 +02:00
+++ b/storage/ndb/src/kernel/blocks/qmgr/QmgrMain.cpp	2008-04-25 11:17:13 +02:00
@@ -252,15 +252,34 @@ Qmgr::execSTART_ORD(Signal* signal)
   {
     ptrAss(nodePtr, nodeRec);
     nodePtr.p->ndynamicId = 0;	
-    if(getNodeInfo(nodePtr.i).m_type == NodeInfo::DB)
-    {
+    Uint32 cnt = 0;
+    Uint32 type = getNodeInfo(nodePtr.i).m_type;
+    switch(type){
+    case NodeInfo::DB:
+      jam();
       nodePtr.p->phase = ZINIT;
       c_definedNodes.set(nodePtr.i);
-    } else {
+      break;
+    case NodeInfo::API:
+      jam();
+      nodePtr.p->phase = ZAPI_INACTIVE;
+      break;
+    case NodeInfo::MGM:
+      jam();
+      /**
+       * Enable communication to MGM direcly
+       *   by setting ZFAIL_CLOSING (picked up in checkStartInterface)
+       */
+      cnt = 3;
+      nodePtr.p->phase = ZFAIL_CLOSING;
+      nodePtr.p->failState = NORMAL;
+      break;
+    default:
+      jam();
       nodePtr.p->phase = ZAPI_INACTIVE;
     }
     
-    setNodeInfo(nodePtr.i).m_heartbeat_cnt= 0;
+    setNodeInfo(nodePtr.i).m_heartbeat_cnt = cnt;
     nodePtr.p->sendPrepFailReqStatus = Q_NOT_ACTIVE;
     nodePtr.p->sendCommitFailReqStatus = Q_NOT_ACTIVE;
     nodePtr.p->sendPresToStatus = Q_NOT_ACTIVE;
@@ -313,6 +332,30 @@ void Qmgr::execSTTOR(Signal* signal) 
       }
     }
     break;
+  case 8:{
+    /**
+     * Enable communication to all API nodes by setting state
+     *   to ZFAIL_CLOSING (which will make it auto-open in checkStartInterface)
+     */
+    c_allow_api_connect = 1;
+    NodeRecPtr nodePtr;
+    for (nodePtr.i = 1; nodePtr.i < MAX_NODES; nodePtr.i++)
+    {
+      jam();
+      Uint32 type = getNodeInfo(nodePtr.i).m_type;
+      if (type != NodeInfo::API)
+        continue;
+
+      ptrAss(nodePtr, nodeRec);
+      if (nodePtr.p->phase == ZAPI_INACTIVE)
+      {
+        jam();
+        setNodeInfo(nodePtr.i).m_heartbeat_cnt = 3;
+        nodePtr.p->phase = ZFAIL_CLOSING;
+        nodePtr.p->failState = NORMAL;
+      }
+    }
+  }
   }
   
   sendSttorryLab(signal);
@@ -325,8 +368,9 @@ void Qmgr::sendSttorryLab(Signal* signal
 /*< STTORRY                  <*/
 /****************************<*/
   signal->theData[3] = 7;
-  signal->theData[4] = 255;
-  sendSignal(NDBCNTR_REF, GSN_STTORRY, signal, 5, JBB);
+  signal->theData[4] = 8;
+  signal->theData[5] = 255;
+  sendSignal(NDBCNTR_REF, GSN_STTORRY, signal, 6, JBB);
   return;
 }//Qmgr::sendSttorryLab()
 
@@ -2178,6 +2222,7 @@ void Qmgr::initData(Signal* signal) 
   cneighbourl = ZNIL;
   cdelayRegreq = ZDELAY_REGREQ;
   cactivateApiCheck = 0;
+  c_allow_api_connect = 0;
   ctoStatus = Q_NOT_ACTIVE;
 
   interface_check_timer.setDelay(1000);
@@ -2493,13 +2538,34 @@ void Qmgr::checkStartInterface(Signal* s
 	 * IS COMPLETE.
 	 *-------------------------------------------------------------------*/
         nodePtr.p->failState = NORMAL;
-        if (getNodeInfo(nodePtr.i).m_type != NodeInfo::DB){
+        Uint32 type = getNodeInfo(nodePtr.i).m_type;
+        switch(type){
+        case NodeInfo::DB:
+          jam();
+          nodePtr.p->phase = ZINIT;
+          break;
+        case NodeInfo::MGM:
           jam();
           nodePtr.p->phase = ZAPI_INACTIVE;
-        } else {
+          break;
+        case NodeInfo::API:
           jam();
-          nodePtr.p->phase = ZINIT;
-        }//if
+          if (c_allow_api_connect)
+          {
+            jam();
+            nodePtr.p->phase = ZAPI_INACTIVE;
+            break;
+          }
+          else
+          {
+            /**
+             * Dont allow API node to connect before c_allow_api_connect
+             */
+            jam();
+            setNodeInfo(nodePtr.i).m_heartbeat_cnt = 3;
+            continue;
+          }
+        }
 
         setNodeInfo(nodePtr.i).m_heartbeat_cnt= 0;
         signal->theData[0] = 0;
diff -Nrup a/storage/ndb/test/ndbapi/test_event.cpp
b/storage/ndb/test/ndbapi/test_event.cpp
--- a/storage/ndb/test/ndbapi/test_event.cpp	2008-03-25 14:24:52 +01:00
+++ b/storage/ndb/test/ndbapi/test_event.cpp	2008-04-25 11:17:13 +02:00
@@ -2075,7 +2075,184 @@ runBug33793(NDBT_Context* ctx, NDBT_Step
   return NDBT_OK;
 }
 
+static
+int
+cc(Ndb_cluster_connection** ctx, Ndb** ndb)
+{
+  Ndb_cluster_connection* xncc = new Ndb_cluster_connection;
+  int ret;
+  if ((ret = xncc->connect(30, 1, 0)) != 0)
+  {
+    delete xncc;
+    return NDBT_FAILED;
+  }
+
+  if ((ret = xncc->wait_until_ready(30, 10)) != 0)
+  {
+    delete xncc;
+    return NDBT_FAILED;
+  }
+
+  Ndb* xndb = new Ndb(xncc, "TEST_DB");
+  if (xndb->init() != 0)
+  {
+    delete xndb;
+    delete xncc;
+    return NDBT_FAILED;
+  }
+
+  if (xndb->waitUntilReady(30) != 0)
+  {
+    delete xndb;
+    delete xncc;
+    return NDBT_FAILED;
+  }
+
+  * ctx = xncc;
+  * ndb = xndb;
+  return 0;
+}
+
+static
+NdbEventOperation*
+op(Ndb* xndb, const NdbDictionary::Table * table)
+{
+  char buf[1024];
+  sprintf(buf, "%s_EVENT", table->getName());
+  NdbEventOperation *pOp;
+  pOp = xndb->createEventOperation(buf);
+  if ( pOp == NULL )
+  {
+    g_err << "Event operation creation failed on %s" << buf << endl;
+    return 0;
+  }
+
+  int n_columns= table->getNoOfColumns();
+  NdbRecAttr* recAttr[1024];
+  NdbRecAttr* recAttrPre[1024];
+  for (int i = 0; i < n_columns; i++) {
+    recAttr[i]    = pOp->getValue(table->getColumn(i)->getName());
+    recAttrPre[i] = pOp->getPreValue(table->getColumn(i)->getName());
+  }
 
+  return pOp;
+}
+
+int
+runBug34853(NDBT_Context* ctx, NDBT_Step* step)
+{
+  int result = NDBT_OK;
+  int loops = ctx->getNumLoops();
+  int records = ctx->getNumRecords();
+  Ndb* pNdb = GETNDB(step);
+  NdbRestarter res;
+
+  if (res.getNumDbNodes() < 2)
+  {
+    return NDBT_OK;
+  }
+
+  Ndb_cluster_connection* xncc;
+  Ndb* xndb;
+
+  if (cc(&xncc, &xndb))
+  {
+    return NDBT_FAILED;
+  }
+
+  NdbEventOperation* pOp = op(xndb, ctx->getTab());
+  if (pOp == 0)
+  {
+    delete xndb;
+    delete xncc;
+    return NDBT_FAILED;
+  }
+
+  int api = xncc->node_id();
+  int nodeId = res.getDbNodeId(rand() % res.getNumDbNodes());
+  ndbout_c("stopping %u", nodeId);
+  res.restartOneDbNode(nodeId,
+                       /** initial */ false,
+                       /** nostart */ true,
+                       /** abort   */ true);
+
+  ndbout_c("waiting for %u", nodeId);
+  res.waitNodesNoStart(&nodeId, 1);
+
+  int dump[2];
+  dump[0] = 9004;
+  dump[1] = api;
+  res.dumpStateOneNode(nodeId, dump, 2);
+  res.startNodes(&nodeId, 1);
+  ndbout_c("waiting cluster");
+  res.waitClusterStarted();
+
+  if (pOp->execute())
+  { // This starts changes to "start flowing"
+    g_err << "execute operation execution failed: \n";
+    g_err << pOp->getNdbError().code << " "
+	  << pOp->getNdbError().message << endl;
+    delete xndb;
+    delete xncc;
+    return NDBT_FAILED;
+  }
+
+  xndb->dropEventOperation(pOp);
+
+  ndbout_c("stopping %u", nodeId);
+  res.restartOneDbNode(nodeId,
+                       /** initial */ false,
+                       /** nostart */ true,
+                       /** abort   */ true);
+
+  ndbout_c("waiting for %u", nodeId);
+  res.waitNodesNoStart(&nodeId, 1);
+
+  dump[0] = 71;
+  dump[1] = 7;
+  res.dumpStateOneNode(nodeId, dump, 2);
+  res.startNodes(&nodeId, 1);
+  ndbout_c("waiting node sp 7");
+  res.waitNodesStartPhase(&nodeId, 1, 6);
+
+  delete xndb;
+  delete xncc;
+
+  NdbSleep_SecSleep(5); // 3 seconds to open connections. i.e 5 > 3
+
+  dump[0] = 71;
+  res.dumpStateOneNode(nodeId, dump, 1);
+
+  res.waitClusterStarted();
+
+  if (cc(&xncc, &xndb))
+  {
+    return NDBT_FAILED;
+  }
+
+  pOp = op(xndb, ctx->getTab());
+  if (pOp == 0)
+  {
+    delete xndb;
+    delete xncc;
+    return NDBT_FAILED;
+  }
+
+  if (pOp->execute())
+  { // This starts changes to "start flowing"
+    g_err << "execute operation execution failed: \n";
+    g_err << pOp->getNdbError().code << " "
+	  << pOp->getNdbError().message << endl;
+    delete xndb;
+    delete xncc;
+    return NDBT_FAILED;
+  }
+
+  xndb->dropEventOperation(pOp);
+  delete xndb;
+  delete xncc;
+  return NDBT_OK;
+}
 
 /** Telco 6.2 **/
 
@@ -2500,6 +2677,11 @@ TESTCASE("Bug33793", ""){
   INITIALIZER(runCreateEvent);
   STEP(runEventListenerUntilStopped);
   STEP(runBug33793);
+  FINALIZER(runDropEvent);
+}
+TESTCASE("Bug34853", ""){
+  INITIALIZER(runCreateEvent);
+  INITIALIZER(runBug34853);
   FINALIZER(runDropEvent);
 }
 TESTCASE("Bug35208", ""){
diff -Nrup a/storage/ndb/test/run-test/daily-basic-tests.txt
b/storage/ndb/test/run-test/daily-basic-tests.txt
--- a/storage/ndb/test/run-test/daily-basic-tests.txt	2008-04-25 09:11:27 +02:00
+++ b/storage/ndb/test/run-test/daily-basic-tests.txt	2008-04-25 11:17:13 +02:00
@@ -1116,4 +1116,8 @@ max-time: 300
 cmd: testNodeRestart
 args: -n Bug36245 T1
 
+max-time: 300
+cmd: test_event
+args: -n Bug34853 T1
+
 # EOF 2008-04-25