bk commit into 5.1 tree (jonas:1.2585) BUG#30975

[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, 2007-09-26 19:21:45+02:00, jonas@stripped +8 -0
  ndb - bug#30975
    Add testcase

  storage/ndb/src/kernel/blocks/dbtc/DbtcMain.cpp@stripped, 2007-09-26 19:21:41+02:00,
jonas@stripped +1 -0
    error insert for crash in timeout in WAIT_COMMIT_CONF

  storage/ndb/src/kernel/blocks/pgman.cpp@stripped, 2007-09-26 19:21:41+02:00,
jonas@stripped +24 -2
    error insert fot blocking of writes

  storage/ndb/test/include/HugoTransactions.hpp@stripped, 2007-09-26 19:21:41+02:00,
jonas@stripped +18 -0
    add
    - loadTableStartFrom
    - scanUpdateRecords with scan flags
    - fillTableStartFrom

  storage/ndb/test/include/UtilTransactions.hpp@stripped, 2007-09-26 19:21:41+02:00,
jonas@stripped +5 -0
    Add 
    - clearTable with scan flags

  storage/ndb/test/ndbapi/testSystemRestart.cpp@stripped, 2007-09-26 19:21:41+02:00,
jonas@stripped +99 -1
    add testcase for bug#30975

  storage/ndb/test/run-test/daily-basic-tests.txt@stripped, 2007-09-26 19:21:41+02:00,
jonas@stripped +4 -0
    add testcase for bug#30975

  storage/ndb/test/src/HugoTransactions.cpp@stripped, 2007-09-26 19:21:41+02:00,
jonas@stripped +83 -48
    add
    - loadTableStartFrom
    - scanUpdateRecords with scan flags
    - fillTableStartFrom

  storage/ndb/test/src/UtilTransactions.cpp@stripped, 2007-09-26 19:21:41+02:00,
jonas@stripped +41 -33
    Add 
    - clearTable with scan flags

# This is a BitKeeper patch.  What follows are the unified diffs for the
# set of deltas contained in the patch.  The rest of the patch, the part
# that BitKeeper cares about, is below these diffs.
# User:	jonas
# Host:	eel.hemma.oreland.se
# Root:	/home/jonas/src/telco-6.1

--- 1.28/storage/ndb/src/kernel/blocks/pgman.cpp	2007-06-26 15:27:40 +02:00
+++ 1.29/storage/ndb/src/kernel/blocks/pgman.cpp	2007-09-26 19:21:41 +02:00
@@ -238,6 +238,13 @@
     }
     else
     {
+      if (ERROR_INSERTED(11007))
+      {
+        ndbout << "No more writes..." << endl;
+        SET_ERROR_INSERT_VALUE(11008);
+        signal->theData[0] = 9999;
+        sendSignalWithDelay(CMVMI_REF, GSN_NDB_TAMPER, signal, 10000, 1);
+      }
       signal->theData[0] = m_end_lcp_req.senderData;
       sendSignal(m_end_lcp_req.senderRef, GSN_END_LCP_CONF, signal, 1, JBB);
     }
@@ -1303,6 +1310,13 @@
     }
     else
     {
+      if (ERROR_INSERTED(11007))
+      {
+        ndbout << "No more writes..." << endl;
+        signal->theData[0] = 9999;
+        sendSignalWithDelay(CMVMI_REF, GSN_NDB_TAMPER, signal, 10000, 1);
+        SET_ERROR_INSERT_VALUE(11008);
+      }
       signal->theData[0] = m_end_lcp_req.senderData;
       sendSignal(m_end_lcp_req.senderRef, GSN_END_LCP_CONF, signal, 1, JBB);
     }
@@ -1590,8 +1604,11 @@
   }
 #endif
   
-  sendSignal(NDBFS_REF, GSN_FSWRITEREQ, signal,
-	     FsReadWriteReq::FixedLength + 1, JBA);
+  if (!ERROR_INSERTED(11008))
+  {
+    sendSignal(NDBFS_REF, GSN_FSWRITEREQ, signal,
+               FsReadWriteReq::FixedLength + 1, JBA);
+  }
 }
 
 void
@@ -2453,6 +2470,11 @@
   if (signal->theData[0] == 11006)
   {
     SET_ERROR_INSERT_VALUE(11006);
+  }
+
+  if (signal->theData[0] == 11007)
+  {
+    SET_ERROR_INSERT_VALUE(11007);
   }
 }
 

--- 1.82/storage/ndb/test/run-test/daily-basic-tests.txt	2007-07-02 14:06:42 +02:00
+++ 1.83/storage/ndb/test/run-test/daily-basic-tests.txt	2007-09-26 19:21:41 +02:00
@@ -878,3 +878,7 @@
 args: -time 60 -p 1 -proc 25
 type: bench
 
+max-time: 500
+cmd: testSystemRestart
+args: -l 2 -n SR_DD D1 D2
+

--- 1.138/storage/ndb/src/kernel/blocks/dbtc/DbtcMain.cpp	2007-07-02 14:05:22 +02:00
+++ 1.139/storage/ndb/src/kernel/blocks/dbtc/DbtcMain.cpp	2007-09-26 19:21:41 +02:00
@@ -6379,6 +6379,7 @@
     return;
   case CS_WAIT_COMMIT_CONF:
     jam();
+    CRASH_INSERTION(8053);
     tcConnectptr.i = apiConnectptr.p->currentTcConnect;
     ptrCheckGuard(tcConnectptr, ctcConnectFilesize, tcConnectRecord);
     arrGuard(apiConnectptr.p->currentReplicaNo, MAX_REPLICAS);

--- 1.15/storage/ndb/test/include/HugoTransactions.hpp	2007-07-14 10:48:06 +02:00
+++ 1.16/storage/ndb/test/include/HugoTransactions.hpp	2007-09-26 19:21:41 +02:00
@@ -36,6 +36,16 @@
 		int updateValue = 0,
 		bool abort = false);
 
+  int loadTableStartFrom(Ndb*, 
+                         int startFrom,
+                         int records,
+                         int batch = 512,
+                         bool allowConstraintViolation = true,
+                         int doSleep = 0,
+                         bool oneTrans = false,
+                         int updateValue = 0,
+                         bool abort = false);
+
   int scanReadRecords(Ndb*, 
 		      int records,
 		      int abort = 0,
@@ -56,6 +66,11 @@
 		    int batchsize = 1,
 		    NdbOperation::LockMode = NdbOperation::LM_Read);
   
+  int scanUpdateRecords(Ndb*, NdbScanOperation::ScanFlag, 
+			int records,
+			int abort = 0,
+			int parallelism = 0);
+
   int scanUpdateRecords(Ndb*, 
 			int records,
 			int abort = 0,
@@ -90,8 +105,11 @@
 		  int records,
 		  int percentToLock = 1,
 		  int lockTime = 1000);
+
   int fillTable(Ndb*,
 		int batch=512);
+
+  int fillTableStartFrom(Ndb*, int startFrom, int batch=512);
 
   /**
    * Reading using UniqHashIndex with key = pk

--- 1.9/storage/ndb/test/include/UtilTransactions.hpp	2006-12-23 20:20:24 +01:00
+++ 1.10/storage/ndb/test/include/UtilTransactions.hpp	2007-09-26 19:21:41 +02:00
@@ -30,6 +30,11 @@
   int closeTransaction(Ndb*);
   
   int clearTable(Ndb*, 
+                 NdbScanOperation::ScanFlag,
+		 int records = 0,
+		 int parallelism = 0);
+
+  int clearTable(Ndb*, 
 		 int records = 0,
 		 int parallelism = 0);
   

--- 1.14/storage/ndb/test/ndbapi/testSystemRestart.cpp	2007-06-18 07:47:22 +02:00
+++ 1.15/storage/ndb/test/ndbapi/testSystemRestart.cpp	2007-09-26 19:21:41 +02:00
@@ -20,6 +20,7 @@
 #include <NdbRestarter.hpp>
 #include <Vector.hpp>
 #include <signaldata/DumpStateOrd.hpp>
+#include <NdbBackup.hpp>
 
 int runLoadTable(NDBT_Context* ctx, NDBT_Step* step){
 
@@ -1261,6 +1262,98 @@
   return result;
 }
 
+int runSRDD(NDBT_Context* ctx, NDBT_Step* step)
+{
+  Ndb* pNdb = GETNDB(step);
+  int result = NDBT_OK;
+  Uint32 loops = ctx->getNumLoops();
+  int count;
+  NdbRestarter restarter;
+  NdbBackup backup(GETNDB(step)->getNodeId()+1);
+  Uint32 i = 1;
+  Uint32 backupId;
+
+  int val[] = { DumpStateOrd::CmvmiSetRestartOnErrorInsert, 1 };
+  int val2 = 11007; // No more writes in pgman after lcp
+
+  int lcp = DumpStateOrd::DihMinTimeBetweenLCP;
+  int lcpnow = DumpStateOrd::DihStartLcpImmediately;
+
+  int startFrom = 0;
+
+  HugoTransactions hugoTrans(*ctx->getTab());
+  while(i<=loops && result != NDBT_FAILED){
+
+    int nodeId = restarter.getDbNodeId(rand() % restarter.getNumDbNodes());
+    //CHECK(restarter.dumpStateAllNodes(&val, 1) == 0);
+
+    ndbout << "Loop " << i << "/"<< loops <<" started"
<< endl;
+    ndbout << "Loading records..." << startFrom << endl;
+    CHECK(hugoTrans.loadTable(pNdb, startFrom) == 0);
+
+    CHECK(hugoTrans.loadTable(pNdb, startFrom, 1000) == 0);
+    CHECK(restarter.dumpStateAllNodes(&lcp, 1) == 0);
+    CHECK(restarter.dumpStateOneNode(nodeId, val, 2) == 0);
+    CHECK(restarter.insertErrorInNode(nodeId, 8053) == 0);
+    CHECK(restarter.dumpStateOneNode(nodeId, &val2, 1) == 0);
+
+    CHECK(restarter.dumpStateAllNodes(&lcpnow, 1) == 0);
+    NdbSleep_SecSleep(1);
+    
+    hugoTrans.loadTable(pNdb, startFrom + 1000, 1000);
+    restarter.dumpStateAllNodes(&lcpnow, 1);
+    CHECK(restarter.waitNodesNoStart(&nodeId, 1) == 0);
+    
+    CHECK(restarter.restartAll(false, true, true) == 0);
+    CHECK(restarter.waitClusterNoStart() == 0);
+    CHECK(restarter.startAll() == 0);
+    CHECK(restarter.waitClusterStarted() == 0);
+    
+    CHECK(backup.start(backupId) == 0);
+    
+    int cnt = 0;
+    CHECK(hugoTrans.selectCount(pNdb, 0, &cnt) == 0);
+    ndbout << "Found " << cnt << " records..." << endl;
+    ndbout << "Clearing..." << endl;    
+    CHECK(hugoTrans.clearTable(pNdb,
+                               NdbScanOperation::SF_TupScan, cnt) == 0);
+    
+    ndbout << "Restarting..." << endl;
+    CHECK(restarter.restartAll(false, true, true) == 0);
+    CHECK(restarter.waitClusterNoStart() == 0);
+    CHECK(restarter.startAll() == 0);
+    CHECK(restarter.waitClusterStarted() == 0);
+    
+    CHECK(backup.start(backupId) == 0);
+
+    int cnt2 = 0;
+    CHECK(hugoTrans.selectCount(pNdb, 0, &cnt2) == 0);
+
+    ndbout << "Loading records...(from " << cnt2 << " to " 
+           << (cnt2 + 1000) << ") " << endl;
+    CHECK(hugoTrans.loadTableStartFrom(pNdb, cnt2, 1000) == 0);
+    CHECK(hugoTrans.selectCount(pNdb, 0, &cnt2) == 0);
+    ndbout << "Clearing..." << endl;
+    CHECK(hugoTrans.clearTable(pNdb,
+                               NdbScanOperation::SF_TupScan, cnt2) == 0);
+    
+    if (cnt + 1000 > startFrom)
+    {
+      startFrom = cnt + 1000;
+    }
+    else
+    {
+      startFrom += 1000;
+    }
+    i++;
+  }
+  
+  ndbout << "runSRDD finished" << endl;  
+
+  return result;
+}
+
+
 NDBT_TESTSUITE(testSystemRestart);
 TESTCASE("SR1", 
 	 "Basic system restart test. Focus on testing restart from REDO log.\n"
@@ -1446,7 +1539,12 @@
   INITIALIZER(runWaitStarted);
   STEP(runBug29167);
 }
-
+TESTCASE("SR_DD", "")
+{
+  INITIALIZER(runWaitStarted);
+  STEP(runSRDD);
+  FINALIZER(runClearTable);
+}
 NDBT_TESTSUITE_END(testSystemRestart);
 
 int main(int argc, const char** argv){

--- 1.34/storage/ndb/test/src/HugoTransactions.cpp	2007-09-11 16:55:08 +02:00
+++ 1.35/storage/ndb/test/src/HugoTransactions.cpp	2007-09-26 19:21:41 +02:00
@@ -341,50 +341,14 @@
 
 int
 HugoTransactions::scanUpdateRecords(Ndb* pNdb, 
-				    int records,
-				    int abortPercent,
-				    int parallelism){
-  if(m_defaultScanUpdateMethod == 1){
-    return scanUpdateRecords1(pNdb, records, abortPercent, parallelism);
-  } else if(m_defaultScanUpdateMethod == 2){
-    return scanUpdateRecords2(pNdb, records, abortPercent, parallelism);
-  } else {
-    return scanUpdateRecords3(pNdb, records, abortPercent, parallelism);
-  }
-}
-
-// Scan all records exclusive and update 
-// them one by one
-int
-HugoTransactions::scanUpdateRecords1(Ndb* pNdb, 
-				     int records,
-				     int abortPercent,
-				     int parallelism){
-  return scanUpdateRecords3(pNdb, records, abortPercent, 1);
-}
-
-// Scan all records exclusive and update 
-// them batched by asking nextScanResult to
-// give us all cached records before fetching new 
-// records from db
-int
-HugoTransactions::scanUpdateRecords2(Ndb* pNdb, 
-				     int records,
-				     int abortPercent,
-				     int parallelism){
-  return scanUpdateRecords3(pNdb, records, abortPercent, parallelism);
-}
-
-int
-HugoTransactions::scanUpdateRecords3(Ndb* pNdb, 
-				     int records,
-				     int abortPercent,
-				     int parallelism){
-  int                  retryAttempt = 0;
+                                    NdbScanOperation::ScanFlag flags,
+                                    int records,
+                                    int abortPercent,
+                                    int parallelism){
+  int retryAttempt = 0;
   int check, a;
   NdbScanOperation *pOp;
 
-
   while (true){
 restart:
     if (retryAttempt++ >= m_retryMax){
@@ -411,8 +375,9 @@
       return NDBT_FAILED;
     }
     
-    if( pOp->readTuplesExclusive(parallelism) ) {
-      ERR(pTrans->getNdbError());
+    if( pOp->readTuples(NdbOperation::LM_Exclusive, flags,
+                        parallelism))
+    {
       closeTransaction(pNdb);
       return NDBT_FAILED;
     }
@@ -517,6 +482,52 @@
 }
 
 int
+HugoTransactions::scanUpdateRecords(Ndb* pNdb, 
+				    int records,
+				    int abortPercent,
+				    int parallelism){
+
+  return scanUpdateRecords(pNdb, 
+                           (NdbScanOperation::ScanFlag)0, 
+                           records, abortPercent, parallelism);
+}
+
+// Scan all records exclusive and update 
+// them one by one
+int
+HugoTransactions::scanUpdateRecords1(Ndb* pNdb, 
+				     int records,
+				     int abortPercent,
+				     int parallelism){
+  return scanUpdateRecords(pNdb, 
+                           (NdbScanOperation::ScanFlag)0, 
+                           records, abortPercent, 1);
+}
+
+// Scan all records exclusive and update 
+// them batched by asking nextScanResult to
+// give us all cached records before fetching new 
+// records from db
+int
+HugoTransactions::scanUpdateRecords2(Ndb* pNdb, 
+				     int records,
+				     int abortPercent,
+				     int parallelism){
+  return scanUpdateRecords(pNdb, (NdbScanOperation::ScanFlag)0, 
+                           records, abortPercent, parallelism);
+}
+
+int
+HugoTransactions::scanUpdateRecords3(Ndb* pNdb, 
+				     int records,
+				     int abortPercent,
+				     int parallelism)
+{
+  return scanUpdateRecords(pNdb, (NdbScanOperation::ScanFlag)0, 
+                           records, abortPercent, parallelism);
+}
+
+int
 HugoTransactions::loadTable(Ndb* pNdb, 
 			    int records,
 			    int batch,
@@ -524,7 +535,22 @@
 			    int doSleep,
                             bool oneTrans,
 			    int value,
-			    bool abort){
+			    bool abort)
+{
+  return loadTableStartFrom(pNdb, 0, records, batch, allowConstraintViolation,
+                            doSleep, oneTrans, value, abort);
+}
+
+int
+HugoTransactions::loadTableStartFrom(Ndb* pNdb, 
+                                     int startFrom,
+                                     int records,
+                                     int batch,
+                                     bool allowConstraintViolation,
+                                     int doSleep,
+                                     bool oneTrans,
+                                     int value,
+                                     bool abort){
   int             check;
   int             retryAttempt = 0;
   int             retryMax = 5;
@@ -543,8 +569,9 @@
 	   << " -> rows/commit = " << batch << endl;
   }
   
+  Uint32 orgbatch = batch;
   g_info << "|- Inserting records..." << endl;
-  for (int c=0 ; c<records ; ){
+  for (int c=0 ; c<records; ){
     bool closeTrans = true;
 
     if(c + batch > records)
@@ -578,7 +605,7 @@
       }
     }
 
-    if(pkInsertRecord(pNdb, c, batch, value) != NDBT_OK)
+    if(pkInsertRecord(pNdb, c + startFrom, batch, value) != NDBT_OK)
     { 
       ERR(pTrans->getNdbError());
       closeTransaction(pNdb);
@@ -625,6 +652,7 @@
 	ERR(err);
 	NdbSleep_MilliSleep(50);
 	retryAttempt++;
+        batch = 1;
 	continue;
 	break;
 	
@@ -670,7 +698,14 @@
 
 int
 HugoTransactions::fillTable(Ndb* pNdb, 
-			    int batch){
+                                     int batch){
+  return fillTableStartFrom(pNdb, 0, batch);
+}
+
+int
+HugoTransactions::fillTableStartFrom(Ndb* pNdb, 
+                                     int startFrom,
+                                     int batch){
   int             check;
   int             retryAttempt = 0;
   int             retryMax = 5;
@@ -688,7 +723,7 @@
 	   << " -> rows/commit = " << batch << endl;
   }
   
-  for (int c=0 ; ; ){
+  for (int c=startFrom ; ; ){
 
     if (retryAttempt >= retryMax){
       g_info << "Record " << c << " could not be inserted, has retried
"

--- 1.25/storage/ndb/test/src/UtilTransactions.cpp	2007-03-15 11:05:58 +01:00
+++ 1.26/storage/ndb/test/src/UtilTransactions.cpp	2007-09-26 19:21:41 +02:00
@@ -42,38 +42,9 @@
 
 int 
 UtilTransactions::clearTable(Ndb* pNdb, 
-			     int records,
-			     int parallelism){
-  if(m_defaultClearMethod == 1){
-    return clearTable1(pNdb, records, parallelism);
-  } else if(m_defaultClearMethod == 2){
-    return clearTable2(pNdb, records, parallelism);
-  } else {
-    return clearTable3(pNdb, records, parallelism);
-  }
-}
-
-
-int 
-UtilTransactions::clearTable1(Ndb* pNdb, 
-			     int records,
-			     int parallelism)
-{
-  return clearTable3(pNdb, records, 1);
-}
-
-int 
-UtilTransactions::clearTable2(Ndb* pNdb, 
-			      int records,
-			      int parallelism)
-{
-  return clearTable3(pNdb, records, parallelism);
-}
-
-int 
-UtilTransactions::clearTable3(Ndb* pNdb, 
-			      int records,
-			      int parallelism){
+                             NdbScanOperation::ScanFlag flags,
+                             int records,
+                             int parallelism){
   // Scan all records exclusive and delete 
   // them one by one
   int                  retryAttempt = 0;
@@ -116,7 +87,7 @@
       goto failed;
     }
     
-    if( pOp->readTuplesExclusive(par) ) {
+    if( pOp->readTuples(NdbOperation::LM_Exclusive, flags, par) ) {
       err = pTrans->getNdbError();
       goto failed;
     }
@@ -177,6 +148,43 @@
   if(pTrans != 0) closeTransaction(pNdb);
   ERR(err);
   return (err.code != 0 ? err.code : NDBT_FAILED);
+}
+
+int 
+UtilTransactions::clearTable(Ndb* pNdb, 
+			     int records,
+			     int parallelism){
+
+  return clearTable(pNdb, (NdbScanOperation::ScanFlag)0,
+                    records, parallelism);
+}
+
+
+int 
+UtilTransactions::clearTable1(Ndb* pNdb, 
+			     int records,
+			     int parallelism)
+{
+  return clearTable(pNdb, (NdbScanOperation::ScanFlag)0,
+                    records, 1);
+}
+
+int 
+UtilTransactions::clearTable2(Ndb* pNdb, 
+			      int records,
+			      int parallelism)
+{
+  return clearTable(pNdb, (NdbScanOperation::ScanFlag)0,
+                    records, parallelism);
+}
+
+int 
+UtilTransactions::clearTable3(Ndb* pNdb, 
+			      int records,
+			      int parallelism)
+{
+  return clearTable(pNdb, (NdbScanOperation::ScanFlag)0,
+                    records, parallelism);
 }
 
 int