开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
testSystemRestart.cpp
资源名称：mysql-4.1.16-win-src.zip　[点击查看]
上传用户：romrleung
上传日期：2022-05-23
资源大小：18897k
文件大小：39k
源码类别：

MySQL数据库

开发平台：

Visual C++

testSystemRestart.cpp：源码内容
  1. /* Copyright (C) 2003 MySQL AB
  3.    This program is free software; you can redistribute it and/or modify
  4.    it under the terms of the GNU General Public License as published by
  5.    the Free Software Foundation; either version 2 of the License, or
  6.    (at your option) any later version.
  8.    This program is distributed in the hope that it will be useful,
  9.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11.    GNU General Public License for more details.
  13.    You should have received a copy of the GNU General Public License
  14.    along with this program; if not, write to the Free Software
  15.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  17. #include <NDBT.hpp>
  18. #include <NDBT_Test.hpp>
  19. #include <HugoTransactions.hpp>
  20. #include <UtilTransactions.hpp>
  21. #include <NdbRestarter.hpp>
  22. #include <Vector.hpp>
  23. #include <signaldata/DumpStateOrd.hpp>
  25. int runLoadTable(NDBT_Context* ctx, NDBT_Step* step){
  27.   int records = ctx->getNumRecords();
  28.   HugoTransactions hugoTrans(*ctx->getTab());
  29.   if (hugoTrans.loadTable(GETNDB(step), records) != 0){
  30.     return NDBT_FAILED;
  31.   }
  32.   return NDBT_OK;
  33. }
  35. #define CHECK(b) if (!(b)) { 
  36.   g_err << "ERR: "<< step->getName() 
  37.          << " failed on line " << __LINE__ << endl; 
  38.   result = NDBT_FAILED; 
  39.   continue; } 
  41. int runSystemRestart1(NDBT_Context* ctx, NDBT_Step* step){
  42.   Ndb* pNdb = GETNDB(step);
  43.   int result = NDBT_OK;
  44.   int timeout = 300;
  45.   Uint32 loops = ctx->getNumLoops();
  46.   int records = ctx->getNumRecords();
  47.   int count;
  48.   NdbRestarter restarter;
  49.   Uint32 i = 1;
  51.   UtilTransactions utilTrans(*ctx->getTab());
  52.   HugoTransactions hugoTrans(*ctx->getTab());
  53.   while(i<=loops && result != NDBT_FAILED){
  55.     ndbout << "Loop " << i << "/"<< loops <<" started" << endl;
  56.     /*
  57.       1. Load data
  58.       2. Restart cluster and verify records
  59.       3. Update records
  60.       4. Restart cluster and verify records
  61.       5. Delete half of the records
  62.       6. Restart cluster and verify records
  63.       7. Delete all records
  64.       8. Restart cluster and verify records
  65.       9. Insert, update, delete records
  66.       10. Restart cluster and verify records
  67.       11. Insert, update, delete records
  68.       12. Restart cluster with error insert 5020 and verify records
  69.     */
  70.     ndbout << "Loading records..." << endl;
  71.     CHECK(hugoTrans.loadTable(pNdb, records) == 0);
  73.     ndbout << "Restarting cluster" << endl;
  74.     CHECK(restarter.restartAll() == 0);
  75.     CHECK(restarter.waitClusterStarted(timeout) == 0);
  76.     CHECK(pNdb->waitUntilReady(timeout) == 0);
  78.     ndbout << "Verifying records..." << endl;
  79.     CHECK(hugoTrans.pkReadRecords(pNdb, records) == 0);
  80.     CHECK(utilTrans.selectCount(pNdb, 64, &count) == 0);
  81.     CHECK(count == records);
  83.     ndbout << "Updating records..." << endl;
  84.     CHECK(hugoTrans.pkUpdateRecords(pNdb, records) == 0);
  86.     ndbout << "Restarting cluster..." << endl;
  87.     CHECK(restarter.restartAll() == 0);
  88.     CHECK(restarter.waitClusterStarted(timeout) == 0);
  89.     CHECK(pNdb->waitUntilReady(timeout) == 0);
  91.     ndbout << "Verifying records..." << endl;
  92.     CHECK(hugoTrans.pkReadRecords(pNdb, records) == 0);
  93.     CHECK(utilTrans.selectCount(pNdb, 64, &count) == 0);
  94.     CHECK(count == records);
  95.     
  96.     ndbout << "Deleting 50% of records..." << endl;
  97.     CHECK(hugoTrans.pkDelRecords(pNdb, records/2) == 0);
  99.     ndbout << "Restarting cluster..." << endl;
  100.     CHECK(restarter.restartAll() == 0);
  101.     CHECK(restarter.waitClusterStarted(timeout) == 0);
  102.     CHECK(pNdb->waitUntilReady(timeout) == 0);
  104.     ndbout << "Verifying records..." << endl;
  105.     CHECK(hugoTrans.scanReadRecords(pNdb, records/2, 0, 64) == 0);
  106.     CHECK(utilTrans.selectCount(pNdb, 64, &count) == 0);
  107.     CHECK(count == (records/2));
  109.     ndbout << "Deleting all records..." << endl;
  110.     CHECK(utilTrans.clearTable(pNdb, records/2) == 0);
  112.     ndbout << "Restarting cluster..." << endl;
  113.     CHECK(restarter.restartAll() == 0);
  114.     CHECK(restarter.waitClusterStarted(timeout) == 0);
  115.     CHECK(pNdb->waitUntilReady(timeout) == 0);
  117.     ndbout << "Verifying records..." << endl;
  118.     CHECK(utilTrans.selectCount(pNdb, 64, &count) == 0);
  119.     CHECK(count == 0);
  121.     ndbout << "Doing it all..." << endl;
  122.     CHECK(hugoTrans.loadTable(pNdb, records) == 0);
  123.     CHECK(hugoTrans.pkUpdateRecords(pNdb, records) == 0);
  124.     CHECK(hugoTrans.pkDelRecords(pNdb, records/2) == 0);
  125.     CHECK(hugoTrans.scanUpdateRecords(pNdb, records) == 0);
  126.     CHECK(utilTrans.clearTable(pNdb, records) == 0);
  127.     CHECK(hugoTrans.loadTable(pNdb, records) == 0);
  128.     CHECK(utilTrans.clearTable(pNdb, records) == 0);
  129.     CHECK(hugoTrans.loadTable(pNdb, records) == 0);
  130.     CHECK(hugoTrans.pkUpdateRecords(pNdb, records) == 0);
  131.     CHECK(utilTrans.clearTable(pNdb, records) == 0);
  133.     ndbout << "Restarting cluster..." << endl;
  134.     CHECK(restarter.restartAll() == 0);
  135.     CHECK(restarter.waitClusterStarted(timeout) == 0);
  136.     CHECK(pNdb->waitUntilReady(timeout) == 0);
  138.     ndbout << "Verifying records..." << endl;
  139.     CHECK(utilTrans.selectCount(pNdb, 64, &count) == 0);
  140.     CHECK(count == 0);
  142.     ndbout << "Doing it all..." << endl;
  143.     CHECK(hugoTrans.loadTable(pNdb, records) == 0);
  144.     CHECK(hugoTrans.pkUpdateRecords(pNdb, records) == 0);
  145.     CHECK(hugoTrans.pkDelRecords(pNdb, records/2) == 0);
  146.     CHECK(hugoTrans.scanUpdateRecords(pNdb, records) == 0);
  147.     CHECK(utilTrans.clearTable(pNdb, records) == 0);
  148.     CHECK(hugoTrans.loadTable(pNdb, records) == 0);
  149.     CHECK(utilTrans.clearTable(pNdb, records) == 0);
  151.     ndbout << "Restarting cluster with error insert 5020..." << endl;
  152.     CHECK(restarter.restartAll(false, true) == 0);
  153.     CHECK(restarter.waitClusterNoStart(timeout) == 0);
  154.     CHECK(restarter.insertErrorInAllNodes(5020) == 0);
  155.     CHECK(restarter.startAll() == 0);
  156.     CHECK(restarter.waitClusterStarted(timeout) == 0);
  157.     CHECK(pNdb->waitUntilReady(timeout) == 0);
  158.     
  159.     i++;
  160.   }
  162.   ndbout << "runSystemRestart1 finished" << endl;  
  164.   return result;
  165. }
  167. int runSystemRestart2(NDBT_Context* ctx, NDBT_Step* step){
  168.   Ndb* pNdb = GETNDB(step);
  169.   int result = NDBT_OK;
  170. ///  int timeout = 300;
  171.   int timeout = 120;
  172.   Uint32 loops = ctx->getNumLoops();
  173.   int records = ctx->getNumRecords();
  174.   int count;
  175.   NdbRestarter restarter;
  176.   Uint32 i = 1;
  178.   UtilTransactions utilTrans(*ctx->getTab());
  179.   HugoTransactions hugoTrans(*ctx->getTab());
  180.   while(i<=loops && result != NDBT_FAILED && !ctx->isTestStopped()){
  182.     ndbout << "Loop " << i << "/"<< loops <<" started" << endl;
  183.     /* Use error 7070 to set time between LCP to it's min value
  184.       1. Load data
  185.       2. Restart cluster and verify records
  186.       3. Update records
  187.       4. Restart cluster and verify records
  188.       5. Delete half of the records
  189.       6. Restart cluster and verify records
  190.       7. Delete all records
  191.       8. Restart cluster and verify records
  192.       9. Insert, update, delete records
  193.       10. Restart cluster and verify records
  194.     */
  195.     int val = DumpStateOrd::DihMinTimeBetweenLCP;
  196.     CHECK(restarter.dumpStateAllNodes(&val, 1) == 0);
  198.     ndbout << "Loading records..." << endl;
  199.     CHECK(hugoTrans.loadTable(pNdb, records) == 0);
  201.     ndbout << "Restarting cluster" << endl;
  202.     CHECK(restarter.restartAll() == 0);
  203.     CHECK(restarter.waitClusterStarted(timeout) == 0);
  204.     {
  205.       int val = DumpStateOrd::DihMinTimeBetweenLCP;
  206.       CHECK(restarter.dumpStateAllNodes(&val, 1) == 0);
  207.     }
  208.     CHECK(pNdb->waitUntilReady(timeout) == 0);
  210.     ndbout << "Verifying records..." << endl;
  211.     CHECK(hugoTrans.pkReadRecords(pNdb, records) == 0);
  212.     CHECK(utilTrans.selectCount(pNdb, 64, &count) == 0);
  213.     CHECK(count == records);
  215.     ndbout << "Updating records..." << endl;
  216.     CHECK(hugoTrans.pkUpdateRecords(pNdb, records) == 0);
  218.     ndbout << "Restarting cluster..." << endl;
  219.     CHECK(restarter.restartAll() == 0);
  220.     CHECK(restarter.waitClusterStarted(timeout) == 0);
  221.     {
  222.       int val = DumpStateOrd::DihMinTimeBetweenLCP;
  223.       CHECK(restarter.dumpStateAllNodes(&val, 1) == 0);
  224.     }
  225.     CHECK(pNdb->waitUntilReady(timeout) == 0);
  227.     ndbout << "Verifying records..." << endl;
  228.     CHECK(hugoTrans.pkReadRecords(pNdb, records) == 0);
  229.     CHECK(utilTrans.selectCount(pNdb, 64, &count) == 0);
  230.     CHECK(count == records);
  231.     
  232.     ndbout << "Deleting 50% of records..." << endl;
  233.     CHECK(hugoTrans.pkDelRecords(pNdb, records/2) == 0);
  235.     ndbout << "Restarting cluster..." << endl;
  236.     CHECK(restarter.restartAll() == 0);
  237.     CHECK(restarter.waitClusterStarted(timeout) == 0);
  238.     {
  239.       int val = DumpStateOrd::DihMinTimeBetweenLCP;
  240.       CHECK(restarter.dumpStateAllNodes(&val, 1) == 0);
  241.     }
  242.     CHECK(pNdb->waitUntilReady(timeout) == 0);
  244.     ndbout << "Verifying records..." << endl;
  245.     CHECK(hugoTrans.scanReadRecords(pNdb, records/2, 0, 64) == 0);
  246.     CHECK(utilTrans.selectCount(pNdb, 64, &count) == 0);
  247.     CHECK(count == (records/2));
  249.     ndbout << "Deleting all records..." << endl;
  250.     CHECK(utilTrans.clearTable(pNdb, records/2) == 0);
  252.     ndbout << "Restarting cluster..." << endl;
  253.     CHECK(restarter.restartAll() == 0);
  254.     CHECK(restarter.waitClusterStarted(timeout) == 0);
  255.     {
  256.       int val = DumpStateOrd::DihMinTimeBetweenLCP;
  257.       CHECK(restarter.dumpStateAllNodes(&val, 1) == 0);
  258.     }
  259.     CHECK(pNdb->waitUntilReady(timeout) == 0);
  261.     ndbout << "Verifying records..." << endl;
  262.     CHECK(utilTrans.selectCount(pNdb, 64, &count) == 0);
  263.     CHECK(count == 0);
  265.     ndbout << "Doing it all..." << endl;
  266.     CHECK(hugoTrans.loadTable(pNdb, records) == 0);
  267.     CHECK(hugoTrans.pkUpdateRecords(pNdb, records) == 0);
  268.     CHECK(hugoTrans.pkDelRecords(pNdb, records/2) == 0);
  269.     CHECK(hugoTrans.scanUpdateRecords(pNdb, records) == 0);
  270.     CHECK(utilTrans.clearTable(pNdb, records) == 0);
  271.     CHECK(hugoTrans.loadTable(pNdb, records) == 0);
  272.     CHECK(utilTrans.clearTable(pNdb, records) == 0);
  273.     CHECK(hugoTrans.loadTable(pNdb, records) == 0);
  274.     CHECK(hugoTrans.pkUpdateRecords(pNdb, records) == 0);
  275.     CHECK(utilTrans.clearTable(pNdb, records) == 0);
  277.     ndbout << "Restarting cluster..." << endl;
  278.     CHECK(restarter.restartAll() == 0);
  279.     CHECK(restarter.waitClusterStarted(timeout) == 0);
  280.     {
  281.       int val = DumpStateOrd::DihMinTimeBetweenLCP;
  282.       CHECK(restarter.dumpStateAllNodes(&val, 1) == 0);
  283.     }
  284.     CHECK(pNdb->waitUntilReady(timeout) == 0);
  286.     ndbout << "Verifying records..." << endl;
  287.     CHECK(utilTrans.selectCount(pNdb, 64, &count) == 0);
  288.     CHECK(count == 0);
  290.     i++;
  291.   }
  293.   ndbout << "runSystemRestart2 finished" << endl;  
  295.   return result;
  296. }
  298. int runSystemRestartTestUndoLog(NDBT_Context* ctx, NDBT_Step* step){
  299.   Ndb* pNdb = GETNDB(step);
  300.   int result = NDBT_OK;
  301.   int timeout = 300;
  302.   Uint32 loops = ctx->getNumLoops();
  303.   int records = ctx->getNumRecords();
  304.   int count;
  305.   NdbRestarter restarter;
  306.   Uint32 i = 1;
  308.   int dump7080[2];
  309.   dump7080[0] = 7080;
  310.   dump7080[1] = ctx->getTab()->getTableId();
  312.   UtilTransactions utilTrans(*ctx->getTab());
  313.   HugoTransactions hugoTrans(*ctx->getTab());
  314.   while(i<=loops && result != NDBT_FAILED){
  316.     ndbout << "Loop " << i << "/"<< loops <<" started" << endl;
  317.     /*
  318.       1. Start LCP, turn on undologging but delay write of datapages.
  319.       2. Insert, update, delete records
  320.       3. Complete writing of data pages and finish LCP.
  321.       4. Restart cluster and verify records
  322.     */
  323.     // Use dump state 7080 to delay writing of datapages
  324.     // for the current table
  325.     ndbout << "Dump state: "<<dump7080[0]<<", "<<dump7080[1]<<endl;
  326.     CHECK(restarter.dumpStateAllNodes(dump7080, 2) == 0);    
  327.     NdbSleep_SecSleep(10);
  329.     ndbout << "Doing it all..." << endl;
  330.     CHECK(hugoTrans.loadTable(pNdb, records) == 0);
  331.     CHECK(hugoTrans.pkUpdateRecords(pNdb, records) == 0);
  332.     CHECK(hugoTrans.pkDelRecords(pNdb, records/2) == 0);
  333.     CHECK(hugoTrans.scanUpdateRecords(pNdb, records) == 0);
  334.     CHECK(utilTrans.clearTable(pNdb, records) == 0);
  335.     CHECK(hugoTrans.loadTable(pNdb, records) == 0);
  336.     CHECK(utilTrans.clearTable(pNdb, records) == 0);
  338.     // Reset error and let LCP continue
  339.     CHECK(restarter.insertErrorInAllNodes(0) == 0);
  340.     NdbSleep_SecSleep(60);
  342.     ndbout << "Restarting cluster..." << endl;
  343.     CHECK(restarter.restartAll() == 0);
  344.     CHECK(restarter.waitClusterStarted(timeout) == 0);
  345.     CHECK(pNdb->waitUntilReady(timeout) == 0);
  347.     ndbout << "Verifying records..." << endl;
  348.     CHECK(utilTrans.selectCount(pNdb, 64, &count) == 0);
  349.     CHECK(count == 0);
  351.     // Use dump state 7080 to delay writing of datapages
  352.     // for the current table
  353.     ndbout << "Dump state: "<<dump7080[0]<<", "<<dump7080[1]<<endl;
  354.     CHECK(restarter.dumpStateAllNodes(dump7080, 2) == 0);
  355.     NdbSleep_SecSleep(10);
  357.     ndbout << "Doing it all, delete 50%..." << endl;
  358.     CHECK(hugoTrans.loadTable(pNdb, records) == 0);
  359.     CHECK(hugoTrans.pkUpdateRecords(pNdb, records) == 0);
  360.     CHECK(hugoTrans.pkDelRecords(pNdb, records/2) == 0);
  362.     // Reset error and let LCP continue
  363.     CHECK(restarter.insertErrorInAllNodes(0) == 0);
  364.     NdbSleep_SecSleep(20);
  366.     ndbout << "Restarting cluster..." << endl;
  367.     CHECK(restarter.restartAll() == 0);
  368.     CHECK(restarter.waitClusterStarted(timeout) == 0);
  369.     CHECK(pNdb->waitUntilReady(timeout) == 0);
  371.     ndbout << "Verifying records..." << endl;
  372.     CHECK(hugoTrans.scanReadRecords(pNdb, records/2, 0, 64) == 0);
  373.     CHECK(utilTrans.selectCount(pNdb, 64, &count) == 0);
  374.     CHECK(count == (records/2));
  375.     CHECK(utilTrans.clearTable(pNdb, records) == 0);
  377.     i++;
  378.   }
  380.   ndbout << "runSystemRestartTestUndoLog finished" << endl;  
  382.   return result;
  383. }
  385. int runSystemRestartTestFullDb(NDBT_Context* ctx, NDBT_Step* step){
  386.   Ndb* pNdb = GETNDB(step);
  387.   int result = NDBT_OK;
  388.   int timeout = 300;
  389.   Uint32 loops = ctx->getNumLoops();
  390.   int count1, count2;
  391.   NdbRestarter restarter;
  392.   Uint32 i = 1;
  394.   UtilTransactions utilTrans(*ctx->getTab());
  395.   HugoTransactions hugoTrans(*ctx->getTab());
  396.   while(i<=loops && result != NDBT_FAILED){
  398.     ndbout << "Loop " << i << "/"<< loops <<" started" << endl;
  399.     /*
  400.       1. Load data until db reports it's full
  401.       2. Restart cluster and verify records
  402.     */
  403.     ndbout << "Filling up table..." << endl;
  404.     CHECK(hugoTrans.fillTable(pNdb) == 0);
  405.     CHECK(utilTrans.selectCount(pNdb, 64, &count1) == 0);
  406.     ndbout << "Db is full. Table has "<<count1 <<" records."<< endl;
  407.     
  408.     ndbout << "Restarting cluster" << endl;
  409.     CHECK(restarter.restartAll() == 0);
  410.     CHECK(restarter.waitClusterStarted(timeout) == 0);
  411.     CHECK(pNdb->waitUntilReady(timeout) == 0);
  413.     ndbout << "Verifying records..." << endl;
  414.     CHECK(hugoTrans.scanReadRecords(pNdb, count1) == 0);
  415.     CHECK(utilTrans.selectCount(pNdb, 64, &count2) == 0);
  416.     CHECK(count1 == count2);
  418.     ndbout << "Deleting all records..." << endl;
  419.     CHECK(utilTrans.clearTable2(pNdb, count1) == 0);
  421.     ndbout << "Restarting cluster..." << endl;
  422.     CHECK(restarter.restartAll() == 0);
  423.     CHECK(restarter.waitClusterStarted(timeout) == 0);
  424.     CHECK(pNdb->waitUntilReady(timeout) == 0);
  426.     ndbout << "Verifying records..." << endl;
  427.     CHECK(utilTrans.selectCount(pNdb, 64, &count1) == 0);
  428.     CHECK(count1 == 0);
  430.     i++;
  431.   }
  433.   ndbout << "runSystemRestartTestFullDb finished" << endl;  
  435.   return result;
  436. }
  438. int runSystemRestart3(NDBT_Context* ctx, NDBT_Step* step){
  439.   Ndb* pNdb = GETNDB(step);
  440.   int result = NDBT_OK;
  441.   int timeout = 300;
  442.   Uint32 loops = ctx->getNumLoops();
  443.   int records = ctx->getNumRecords();
  444.   int count;
  445.   NdbRestarter restarter;
  446.   Uint32 i = 1;
  448.   const Uint32 nodeCount = restarter.getNumDbNodes();
  449.   if(nodeCount < 2){
  450.     g_info << "SR3 - Needs atleast 2 nodes to test" << endl;
  451.     return NDBT_OK;
  452.   }
  454.   Vector<int> nodeIds;
  455.   for(i = 0; i<nodeCount; i++)
  456.     nodeIds.push_back(restarter.getDbNodeId(i));
  457.   
  458.   Uint32 currentRestartNodeIndex = 0;
  459.   UtilTransactions utilTrans(*ctx->getTab());
  460.   HugoTransactions hugoTrans(*ctx->getTab());
  461.   
  462.   while(i<=loops && result != NDBT_FAILED){
  463.     
  464.     g_info << "Loop " << i << "/"<< loops <<" started" << endl;
  465.     /**
  466.      * 1. Load data
  467.      * 2. Restart 1 node -nostart
  468.      * 3. Update records
  469.      * 4. Restart cluster and verify records
  470.      * 5. Restart 1 node -nostart
  471.      * 6. Delete half of the records
  472.      * 7. Restart cluster and verify records
  473.      * 8. Restart 1 node -nostart
  474.      * 9. Delete all records
  475.      * 10. Restart cluster and verify records
  476.      */
  477.     g_info << "Loading records..." << endl;
  478.     CHECK(hugoTrans.loadTable(pNdb, records) == 0);
  480.     /*** 1 ***/
  481.     g_info << "1 - Stopping one node" << endl;
  482.     CHECK(restarter.restartOneDbNode(nodeIds[currentRestartNodeIndex],
  483.      false, 
  484.      true,
  485.      false) == 0);
  486.     currentRestartNodeIndex = (currentRestartNodeIndex + 1 ) % nodeCount;
  488.     g_info << "Updating records..." << endl;
  489.     CHECK(hugoTrans.pkUpdateRecords(pNdb, records) == 0);
  490.     
  491.     g_info << "Restarting cluster..." << endl;
  492.     CHECK(restarter.restartAll() == 0);
  493.     CHECK(restarter.waitClusterStarted(timeout) == 0);
  494.     CHECK(pNdb->waitUntilReady(timeout) == 0);
  496.     g_info << "Verifying records..." << endl;
  497.     CHECK(hugoTrans.pkReadRecords(pNdb, records) == 0);
  498.     CHECK(utilTrans.selectCount(pNdb, 64, &count) == 0);
  499.     CHECK(count == records);
  501.     g_info << "2 - Stopping one node" << endl;
  502.     CHECK(restarter.restartOneDbNode(nodeIds[currentRestartNodeIndex],
  503.      false, 
  504.      true,
  505.      false) == 0);
  506.     currentRestartNodeIndex = (currentRestartNodeIndex + 1 ) % nodeCount;
  508.     g_info << "Deleting 50% of records..." << endl;
  509.     CHECK(hugoTrans.pkDelRecords(pNdb, records/2) == 0);
  510.     
  511.     g_info << "Restarting cluster..." << endl;
  512.     CHECK(restarter.restartAll() == 0);
  513.     CHECK(restarter.waitClusterStarted(timeout) == 0);
  514.     CHECK(pNdb->waitUntilReady(timeout) == 0);
  516.     g_info << "Verifying records..." << endl;
  517.     CHECK(hugoTrans.scanReadRecords(pNdb, records/2, 0, 64) == 0);
  518.     CHECK(utilTrans.selectCount(pNdb, 64, &count) == 0);
  519.     CHECK(count == (records/2));
  521.     g_info << "3 - Stopping one node" << endl;
  522.     CHECK(restarter.restartOneDbNode(nodeIds[currentRestartNodeIndex],
  523.      false, 
  524.      true,
  525.      false) == 0);
  526.     currentRestartNodeIndex = (currentRestartNodeIndex + 1 ) % nodeCount;
  527.     g_info << "Deleting all records..." << endl;
  528.     CHECK(utilTrans.clearTable(pNdb, records/2) == 0);
  530.     g_info << "Restarting cluster..." << endl;
  531.     CHECK(restarter.restartAll() == 0);
  532.     CHECK(restarter.waitClusterStarted(timeout) == 0);
  533.     CHECK(pNdb->waitUntilReady(timeout) == 0);
  534.     
  535.     ndbout << "Verifying records..." << endl;
  536.     CHECK(utilTrans.selectCount(pNdb, 64, &count) == 0);
  537.     CHECK(count == 0);
  538.     
  539.     i++;
  540.   }
  542.   g_info << "runSystemRestart3 finished" << endl;  
  544.   return result;
  545. }
  547. int runSystemRestart4(NDBT_Context* ctx, NDBT_Step* step){
  548.   Ndb* pNdb = GETNDB(step);
  549.   int result = NDBT_OK;
  550.   int timeout = 300;
  551.   Uint32 loops = ctx->getNumLoops();
  552.   int records = ctx->getNumRecords();
  553.   int count;
  554.   NdbRestarter restarter;
  555.   Uint32 i = 1;
  557.   const Uint32 nodeCount = restarter.getNumDbNodes();
  558.   if(nodeCount < 2){
  559.     g_info << "SR4 - Needs atleast 2 nodes to test" << endl;
  560.     return NDBT_OK;
  561.   }
  563.   Vector<int> nodeIds;
  564.   for(i = 0; i<nodeCount; i++)
  565.     nodeIds.push_back(restarter.getDbNodeId(i));
  566.   
  567.   Uint32 currentRestartNodeIndex = 0;
  568.   UtilTransactions utilTrans(*ctx->getTab());
  569.   HugoTransactions hugoTrans(*ctx->getTab());
  571.   {
  572.     int val = DumpStateOrd::DihMinTimeBetweenLCP;
  573.     if(restarter.dumpStateAllNodes(&val, 1) != 0){
  574.       g_err << "ERR: "<< step->getName() 
  575.     << " failed on line " << __LINE__ << endl; 
  576.       return NDBT_FAILED;
  577.     }
  578.   }
  579.   
  580.   while(i<=loops && result != NDBT_FAILED){
  581.     
  582.     g_info << "Loop " << i << "/"<< loops <<" started" << endl;
  583.     /**
  584.      * 1. Load data
  585.      * 2. Restart 1 node -nostart
  586.      * 3. Update records
  587.      * 4. Restart cluster and verify records
  588.      * 5. Restart 1 node -nostart
  589.      * 6. Delete half of the records
  590.      * 7. Restart cluster and verify records
  591.      * 8. Restart 1 node -nostart
  592.      * 9. Delete all records
  593.      * 10. Restart cluster and verify records
  594.      */
  595.     g_info << "Loading records..." << endl;
  596.     CHECK(hugoTrans.loadTable(pNdb, records) == 0);
  598.     /*** 1 ***/
  599.     g_info << "1 - Stopping one node" << endl;
  600.     CHECK(restarter.restartOneDbNode(nodeIds[currentRestartNodeIndex],
  601.      false, 
  602.      true,
  603.      false) == 0);
  604.     currentRestartNodeIndex = (currentRestartNodeIndex + 1 ) % nodeCount;
  606.     g_info << "Updating records..." << endl;
  607.     CHECK(hugoTrans.pkUpdateRecords(pNdb, records) == 0);
  608.     
  609.     g_info << "Restarting cluster..." << endl;
  610.     CHECK(restarter.restartAll() == 0);
  611.     CHECK(restarter.waitClusterStarted(timeout) == 0);
  612.     {
  613.       int val = DumpStateOrd::DihMinTimeBetweenLCP;
  614.       CHECK(restarter.dumpStateAllNodes(&val, 1) == 0);
  615.     }
  616.     CHECK(pNdb->waitUntilReady(timeout) == 0);
  618.     g_info << "Verifying records..." << endl;
  619.     CHECK(hugoTrans.pkReadRecords(pNdb, records) == 0);
  620.     CHECK(utilTrans.selectCount(pNdb, 64, &count) == 0);
  621.     CHECK(count == records);
  623.     g_info << "2 - Stopping one node" << endl;
  624.     CHECK(restarter.restartOneDbNode(nodeIds[currentRestartNodeIndex],
  625.      false, 
  626.      true,
  627.      false) == 0);
  628.     currentRestartNodeIndex = (currentRestartNodeIndex + 1 ) % nodeCount;
  630.     g_info << "Deleting 50% of records..." << endl;
  631.     CHECK(hugoTrans.pkDelRecords(pNdb, records/2) == 0);
  632.     
  633.     g_info << "Restarting cluster..." << endl;
  634.     CHECK(restarter.restartAll() == 0);
  635.     CHECK(restarter.waitClusterStarted(timeout) == 0);
  636.     {
  637.       int val = DumpStateOrd::DihMinTimeBetweenLCP;
  638.       CHECK(restarter.dumpStateAllNodes(&val, 1) == 0);
  639.     }
  640.     CHECK(pNdb->waitUntilReady(timeout) == 0);
  642.     g_info << "Verifying records..." << endl;
  643.     CHECK(hugoTrans.scanReadRecords(pNdb, records/2, 0, 64) == 0);
  644.     CHECK(utilTrans.selectCount(pNdb, 64, &count) == 0);
  645.     CHECK(count == (records/2));
  647.     g_info << "3 - Stopping one node" << endl;
  648.     CHECK(restarter.restartOneDbNode(nodeIds[currentRestartNodeIndex],
  649.      false, 
  650.      true,
  651.      false) == 0);
  652.     currentRestartNodeIndex = (currentRestartNodeIndex + 1 ) % nodeCount;
  653.     g_info << "Deleting all records..." << endl;
  654.     CHECK(utilTrans.clearTable(pNdb, records/2) == 0);
  656.     g_info << "Restarting cluster..." << endl;
  657.     CHECK(restarter.restartAll() == 0);
  658.     CHECK(restarter.waitClusterStarted(timeout) == 0);
  659.     {
  660.       int val = DumpStateOrd::DihMinTimeBetweenLCP;
  661.       CHECK(restarter.dumpStateAllNodes(&val, 1) == 0);
  662.     }
  663.     CHECK(pNdb->waitUntilReady(timeout) == 0);
  664.     
  665.     ndbout << "Verifying records..." << endl;
  666.     CHECK(utilTrans.selectCount(pNdb, 64, &count) == 0);
  667.     CHECK(count == 0);
  668.     
  669.     i++;
  670.   }
  672.   g_info << "runSystemRestart4 finished" << endl;  
  674.   return result;
  675. }
  677. int runSystemRestart5(NDBT_Context* ctx, NDBT_Step* step){
  678.   Ndb* pNdb = GETNDB(step);
  679.   int result = NDBT_OK;
  680.   int timeout = 300;
  681.   Uint32 loops = ctx->getNumLoops();
  682.   int records = ctx->getNumRecords();
  683.   int count;
  684.   NdbRestarter restarter;
  685.   Uint32 i = 1;
  687.   const Uint32 nodeCount = restarter.getNumDbNodes();
  688.   if(nodeCount < 2){
  689.     g_info << "SR5 - Needs atleast 2 nodes to test" << endl;
  690.     return NDBT_OK;
  691.   }
  693.   Vector<int> nodeIds;
  694.   for(i = 0; i<nodeCount; i++)
  695.     nodeIds.push_back(restarter.getDbNodeId(i));
  696.   
  697.   Uint32 currentRestartNodeIndex = 0;
  698.   UtilTransactions utilTrans(*ctx->getTab());
  699.   HugoTransactions hugoTrans(*ctx->getTab());
  701.   {
  702.     int val = DumpStateOrd::DihMinTimeBetweenLCP;
  703.     if(restarter.dumpStateAllNodes(&val, 1) != 0){
  704.       g_err << "ERR: "<< step->getName() 
  705.     << " failed on line " << __LINE__ << endl; 
  706.       return NDBT_FAILED;
  707.     }
  708.   }
  709.   
  710.   while(i<=loops && result != NDBT_FAILED){
  711.     
  712.     g_info << "Loop " << i << "/"<< loops <<" started" << endl;
  713.     /**
  714.      * 1. Load data
  715.      * 2. Restart 1 node -nostart
  716.      * 3. Update records
  717.      * 4. Restart cluster and verify records
  718.      * 5. Restart 1 node -nostart
  719.      * 6. Delete half of the records
  720.      * 7. Restart cluster and verify records
  721.      * 8. Restart 1 node -nostart
  722.      * 9. Delete all records
  723.      * 10. Restart cluster and verify records
  724.      */
  725.     g_info << "Loading records..." << endl;
  726.     hugoTrans.loadTable(pNdb, records);
  728.     /*** 1 ***/
  729.     g_info << "1 - Stopping one node" << endl;
  730.     CHECK(restarter.restartOneDbNode(nodeIds[currentRestartNodeIndex],
  731.      false, 
  732.      true,
  733.      false) == 0);
  734.     currentRestartNodeIndex = (currentRestartNodeIndex + 1 ) % nodeCount;
  736.     g_info << "Updating records..." << endl;
  737.     hugoTrans.pkUpdateRecords(pNdb, records);
  738.     
  739.     g_info << "Restarting cluster..." << endl;
  740.     CHECK(restarter.restartAll(false, false, true) == 0);
  741.     CHECK(restarter.waitClusterStarted(timeout) == 0);
  742.     {
  743.       int val = DumpStateOrd::DihMinTimeBetweenLCP;
  744.       CHECK(restarter.dumpStateAllNodes(&val, 1) == 0);
  745.     }
  746.     CHECK(pNdb->waitUntilReady(timeout) == 0);
  748.     g_info << "Verifying records..." << endl;
  749.     hugoTrans.pkReadRecords(pNdb, records);
  750.     CHECK(utilTrans.selectCount(pNdb, 64, &count) == 0);
  751.     //CHECK(count == records);
  753.     g_info << "2 - Stopping one node" << endl;
  754.     CHECK(restarter.restartOneDbNode(nodeIds[currentRestartNodeIndex],
  755.      false, 
  756.      true,
  757.      false) == 0);
  758.     currentRestartNodeIndex = (currentRestartNodeIndex + 1 ) % nodeCount;
  760.     g_info << "Deleting 50% of records..." << endl;
  761.     hugoTrans.pkDelRecords(pNdb, records/2);
  762.     
  763.     g_info << "Restarting cluster..." << endl;
  764.     CHECK(restarter.restartAll(false, false, true) == 0);
  765.     CHECK(restarter.waitClusterStarted(timeout) == 0);
  766.     {
  767.       int val = DumpStateOrd::DihMinTimeBetweenLCP;
  768.       CHECK(restarter.dumpStateAllNodes(&val, 1) == 0);
  769.     }
  770.     CHECK(pNdb->waitUntilReady(timeout) == 0);
  772.     g_info << "Verifying records..." << endl;
  773.     hugoTrans.scanReadRecords(pNdb, records/2, 0, 64);
  774.     CHECK(utilTrans.selectCount(pNdb, 64, &count) == 0);
  775.     //CHECK(count == (records/2));
  777.     g_info << "3 - Stopping one node" << endl;
  778.     CHECK(restarter.restartOneDbNode(nodeIds[currentRestartNodeIndex],
  779.      false, 
  780.      true,
  781.      false) == 0);
  782.     currentRestartNodeIndex = (currentRestartNodeIndex + 1 ) % nodeCount;
  783.     g_info << "Deleting all records..." << endl;
  784.     utilTrans.clearTable(pNdb, records/2);
  786.     g_info << "Restarting cluster..." << endl;
  787.     CHECK(restarter.restartAll(false, false, true) == 0);
  788.     CHECK(restarter.waitClusterStarted(timeout) == 0);
  789.     {
  790.       int val = DumpStateOrd::DihMinTimeBetweenLCP;
  791.       CHECK(restarter.dumpStateAllNodes(&val, 1) == 0);
  792.     }
  793.     CHECK(pNdb->waitUntilReady(timeout) == 0);
  794.     
  795.     ndbout << "Verifying records..." << endl;
  796.     CHECK(utilTrans.selectCount(pNdb, 64, &count) == 0);
  797.     //CHECK(count == 0);
  798.     
  799.     CHECK(utilTrans.clearTable(pNdb) == 0);    
  800.     i++;
  801.   }
  803.   g_info << "runSystemRestart5 finished" << endl;  
  805.   return result;
  806. }
  808. int runSystemRestart6(NDBT_Context* ctx, NDBT_Step* step){
  809.   Ndb* pNdb = GETNDB(step);
  810.   int result = NDBT_OK;
  811.   int timeout = 300;
  812.   Uint32 loops = ctx->getNumLoops();
  813.   int records = ctx->getNumRecords();
  814.   NdbRestarter restarter;
  815.   Uint32 i = 1;
  817.   const Uint32 nodeCount = restarter.getNumDbNodes();
  818.   if(nodeCount < 2){
  819.     g_info << "SR6 - Needs atleast 2 nodes to test" << endl;
  820.     return NDBT_OK;
  821.   }
  823.   Vector<int> nodeIds;
  824.   for(i = 0; i<nodeCount; i++)
  825.     nodeIds.push_back(restarter.getDbNodeId(i));
  826.   
  827.   Uint32 currentRestartNodeIndex = 0;
  828.   UtilTransactions utilTrans(*ctx->getTab());
  829.   HugoTransactions hugoTrans(*ctx->getTab());
  831.   while(i<=loops && result != NDBT_FAILED){
  832.     
  833.     g_info << "Loop " << i << "/"<< loops <<" started" << endl;
  834.     /**
  835.      * 1. Load data
  836.      * 2. Restart all node -nostart
  837.      * 3. Restart some nodes -i -nostart
  838.      * 4. Start all nodes verify records
  839.      */
  840.     g_info << "Loading records..." << endl;
  841.     hugoTrans.loadTable(pNdb, records);
  843.     CHECK(restarter.restartAll(false, true, false) == 0);
  845.     Uint32 nodeId = nodeIds[currentRestartNodeIndex];
  846.     currentRestartNodeIndex = (currentRestartNodeIndex + 1 ) % nodeCount;
  847.     
  848.     CHECK(restarter.restartOneDbNode(nodeId, true, true,false) == 0);
  849.     CHECK(restarter.waitClusterNoStart(timeout) == 0);
  850.     CHECK(restarter.startAll() == 0);
  851.     CHECK(restarter.waitClusterStarted(timeout) == 0);
  852.     CHECK(pNdb->waitUntilReady(timeout) == 0);
  853.     int count = records - 1;
  854.     CHECK(utilTrans.selectCount(pNdb, 64, &count) == 0);
  855.     CHECK(count == records);
  856.     CHECK(utilTrans.clearTable(pNdb) == 0);    
  857.     i++;
  858.   }
  860.   g_info << "runSystemRestart6 finished" << endl;  
  862.   return result;
  863. }
  865. int runSystemRestart7(NDBT_Context* ctx, NDBT_Step* step){
  866.   Ndb* pNdb = GETNDB(step);
  867.   int result = NDBT_OK;
  868.   Uint32 loops = ctx->getNumLoops();
  869.   int records = ctx->getNumRecords();
  870.   NdbRestarter restarter;
  871.   Uint32 i = 1;
  873.   const Uint32 nodeCount = restarter.getNumDbNodes();
  874.   if(nodeCount < 2){
  875.     g_info << "SR7 - Needs atleast 2 nodes to test" << endl;
  876.     return NDBT_OK;
  877.   }
  879.   Vector<int> nodeIds;
  880.   for(i = 0; i<nodeCount; i++)
  881.     nodeIds.push_back(restarter.getDbNodeId(i));
  883.   int a_nodeIds[64];
  884.   if(nodeCount > 64)
  885.     abort();
  887.   Uint32 currentRestartNodeIndex = 1;
  888.   UtilTransactions utilTrans(*ctx->getTab());
  889.   HugoTransactions hugoTrans(*ctx->getTab());
  891.   while(i<=loops && result != NDBT_FAILED){
  892.     
  893.     g_info << "Loop " << i << "/"<< loops <<" started" << endl;
  894.     /**
  895.      * 1. Load data
  896.      * 2. Restart all node -nostart
  897.      * 3. Start all but one node
  898.      * 4. Wait for startphase >= 2
  899.      * 5. Start last node
  900.      * 6. Verify records
  901.      */
  902.     g_info << "Loading records..." << endl;
  903.     hugoTrans.loadTable(pNdb, records);
  904.     
  905.     CHECK(restarter.restartAll(false, true, false) == 0);
  906.     
  907.     int nodeId = nodeIds[currentRestartNodeIndex];
  908.     currentRestartNodeIndex = (currentRestartNodeIndex + 1 ) % nodeCount;
  910.     Uint32 j = 0;
  911.     for(Uint32 k = 0; k<nodeCount; k++){
  912.       if(nodeIds[k] != nodeId){
  913. a_nodeIds[j++] = nodeIds[k];
  914.       }
  915.     }
  917.     CHECK(restarter.startNodes(a_nodeIds, nodeCount - 1) == 0);
  918.     CHECK(restarter.waitNodesStarted(a_nodeIds, nodeCount - 1, 120) == 0);
  919.     CHECK(pNdb->waitUntilReady(5) == 0);
  920.     int count = records - 1;
  921.     CHECK(utilTrans.selectCount(pNdb, 64, &count) == 0);
  922.     CHECK(count == records);
  923.     
  924.     CHECK(restarter.startNodes(&nodeId, 1) == 0);
  925.     CHECK(restarter.waitNodesStarted(&nodeId, 1, 120) == 0);
  926.     
  927.     CHECK(utilTrans.selectCount(pNdb, 64, &count) == 0);
  928.     CHECK(count == records);
  929.     CHECK(utilTrans.clearTable(pNdb) == 0);    
  931.     i++;
  932.   }
  933.   
  934.   g_info << "runSystemRestart7 finished" << endl;  
  936.   return result;
  937. }
  939. int runSystemRestart8(NDBT_Context* ctx, NDBT_Step* step){
  940.   Ndb* pNdb = GETNDB(step);
  941.   int result = NDBT_OK;
  942.   int timeout = 300;
  943.   Uint32 loops = ctx->getNumLoops();
  944.   int records = ctx->getNumRecords();
  945.   NdbRestarter restarter;
  946.   Uint32 i = 1;
  948.   const Uint32 nodeCount = restarter.getNumDbNodes();
  949.   if(nodeCount < 2){
  950.     g_info << "SR8 - Needs atleast 2 nodes to test" << endl;
  951.     return NDBT_OK;
  952.   }
  954.   Vector<int> nodeIds;
  955.   for(i = 0; i<nodeCount; i++)
  956.     nodeIds.push_back(restarter.getDbNodeId(i));
  958.   int a_nodeIds[64];
  959.   if(nodeCount > 64)
  960.     abort();
  962.   Uint32 currentRestartNodeIndex = 1;
  963.   UtilTransactions utilTrans(*ctx->getTab());
  964.   HugoTransactions hugoTrans(*ctx->getTab());
  966.   while(i<=loops && result != NDBT_FAILED){
  967.     
  968.     g_info << "Loop " << i << "/"<< loops <<" started" << endl;
  969.     /**
  970.      * 1. Load data
  971.      * 2. Restart all node -nostart
  972.      * 3. Start all but one node
  973.      * 4. Verify records
  974.      * 5. Start last node
  975.      * 6. Verify records
  976.      */
  977.     g_info << "Loading records..." << endl;
  978.     hugoTrans.loadTable(pNdb, records);
  979.     
  980.     CHECK(restarter.restartAll(false, true, false) == 0);
  981.     
  982.     int nodeId = nodeIds[currentRestartNodeIndex];
  983.     currentRestartNodeIndex = (currentRestartNodeIndex + 1 ) % nodeCount;
  985.     Uint32 j = 0;
  986.     for(Uint32 k = 0; k<nodeCount; k++){
  987.       if(nodeIds[k] != nodeId){
  988. a_nodeIds[j++] = nodeIds[k];
  989.       }
  990.     }
  991.     
  992.     CHECK(restarter.startNodes(a_nodeIds, nodeCount-1) == 0);
  993.     CHECK(restarter.waitNodesStartPhase(a_nodeIds, nodeCount-1, 3, 120) == 0);
  994.     CHECK(restarter.startNodes(&nodeId, 1) == 0);
  995.     CHECK(restarter.waitClusterStarted(timeout) == 0);
  996.     
  997.     int count = records - 1;
  998.     CHECK(utilTrans.selectCount(pNdb, 64, &count) == 0);
  999.     CHECK(count == records);
  1000.     CHECK(utilTrans.clearTable(pNdb) == 0);    
  1001.     i++;
  1002.   }
  1003.   
  1004.   g_info << "runSystemRestart8 finished" << endl;  
  1006.   return result;
  1007. }
  1009. int runSystemRestart9(NDBT_Context* ctx, NDBT_Step* step){
  1010.   Ndb* pNdb = GETNDB(step);
  1011.   int result = NDBT_OK;
  1012.   int timeout = 300;
  1013.   Uint32 loops = ctx->getNumLoops();
  1014.   int records = ctx->getNumRecords();
  1015.   NdbRestarter restarter;
  1016.   Uint32 i = 1;
  1017.   
  1018.   Uint32 currentRestartNodeIndex = 1;
  1019.   UtilTransactions utilTrans(*ctx->getTab());
  1020.   HugoTransactions hugoTrans(*ctx->getTab());
  1022.   int args[] = { DumpStateOrd::DihMaxTimeBetweenLCP };
  1023.   int dump[] = { DumpStateOrd::DihStartLcpImmediately };
  1024.   
  1025.   do {
  1026.     CHECK(restarter.dumpStateAllNodes(args, 1) == 0);
  1027.     
  1028.     HugoOperations ops(* ctx->getTab());
  1029.     CHECK(ops.startTransaction(pNdb) == 0);
  1030.     for(i = 0; i<10; i++){
  1031.       CHECK(ops.pkInsertRecord(pNdb, i, 1, 1) == 0);
  1032.       CHECK(ops.execute_NoCommit(pNdb) == 0);
  1033.     }
  1034.     for(i = 0; i<10; i++){
  1035.       CHECK(ops.pkUpdateRecord(pNdb, i, 1) == 0);
  1036.       CHECK(ops.execute_NoCommit(pNdb) == 0);
  1037.     }
  1038.     NdbSleep_SecSleep(10);
  1039.     CHECK(restarter.dumpStateAllNodes(dump, 1) == 0);
  1040.     NdbSleep_SecSleep(10);
  1041.     CHECK(ops.execute_Commit(pNdb) == 0);  
  1042.     
  1043.     CHECK(restarter.restartAll() == 0);
  1044.     CHECK(restarter.waitClusterStarted(timeout) == 0);
  1045.     CHECK(pNdb->waitUntilReady(timeout) == 0);
  1046.     ops.closeTransaction(pNdb);
  1047.   } while(0);
  1048.   
  1049.   g_info << "runSystemRestart9 finished" << endl;  
  1051.   return result;
  1052. }
  1054. int runWaitStarted(NDBT_Context* ctx, NDBT_Step* step){
  1056.   NdbRestarter restarter;
  1057.   restarter.waitClusterStarted(300);
  1059.   NdbSleep_SecSleep(3);
  1060.   return NDBT_OK;
  1061. }
  1063. int runClearTable(NDBT_Context* ctx, NDBT_Step* step){
  1064.   int records = ctx->getNumRecords();
  1065.   
  1066.   Ndb* pNdb = GETNDB(step);
  1067.   if(pNdb->waitUntilReady(5) != 0){
  1068.     return NDBT_FAILED;
  1069.   }
  1071.   UtilTransactions utilTrans(*ctx->getTab());  
  1072.   if (utilTrans.clearTable2(pNdb,  records) != 0){
  1073.     return NDBT_FAILED;
  1074.   }
  1075.   return NDBT_OK;
  1076. }
  1079. NDBT_TESTSUITE(testSystemRestart);
  1080. TESTCASE("SR1", 
  1081.  "Basic system restart test. Focus on testing restart from REDO log.n"
  1082.  "NOTE! Time between lcp's and gcp's should be left at default, n"
  1083.  "so that Ndb  uses the Redo log when restartingn" 
  1084.  "1. Load recordsn"
  1085.  "2. Restart cluster and verify records n"
  1086.  "3. Update recordsn"
  1087.  "4. Restart cluster and verify records n"
  1088.  "5. Delete half of the records n"
  1089.  "6. Restart cluster and verify records n"
  1090.  "7. Delete all records n"
  1091.  "8. Restart cluster and verify records n"
  1092.  "9. Insert, update, delete records n"
  1093.  "10. Restart cluster and verify recordsn"
  1094.  "11. Insert, update, delete records n"
  1095.  "12. Restart cluster with error insert 5020 and verify recordsn"){ 
  1096.   INITIALIZER(runWaitStarted);
  1097.   STEP(runSystemRestart1);
  1098.   FINALIZER(runClearTable);
  1099. }
  1100. TESTCASE("SR2", 
  1101.  "Basic system restart test. Focus on testing restart from LCPn"
  1102.  "NOTE! Time between lcp's is automatically set to it's  min valuen"
  1103.  "so that Ndb  uses LCP's when restarting.n" 
  1104.  "1. Load recordsn"
  1105.  "2. Restart cluster and verify records n"
  1106.  "3. Update recordsn"
  1107.  "4. Restart cluster and verify records n"
  1108.  "5. Delete half of the records n"
  1109.  "6. Restart cluster and verify records n"
  1110.  "7. Delete all records n"
  1111.  "8. Restart cluster and verify records n"
  1112.  "9. Insert, update, delete records n"
  1113.  "10. Restart cluster and verify recordsn"){
  1114.   INITIALIZER(runWaitStarted);
  1115.   STEP(runSystemRestart2);
  1116.   FINALIZER(runClearTable);
  1117. }
  1118. TESTCASE("SR_UNDO", 
  1119.  "System restart test. Focus on testing of undologgingn"
  1120.  "in DBACC and DBTUP.n"
  1121.  "This is done by starting a LCP, turn on undologging n"
  1122.  "but don't start writing the datapages. This will force alln"
  1123.  "operations to be written into the undolog.n"
  1124.  "Then write datapages and complete LCP.n"
  1125.  "Restart the systemn"){
  1126.   INITIALIZER(runWaitStarted);
  1127.   STEP(runSystemRestartTestUndoLog);
  1128.   FINALIZER(runClearTable);
  1129. }
  1130. TESTCASE("SR_FULLDB", 
  1131.  "System restart test. Test to restart when DB is full.n"){
  1132.   INITIALIZER(runWaitStarted);
  1133.   STEP(runSystemRestartTestFullDb);
  1134.   FINALIZER(runClearTable);
  1135. }
  1136. TESTCASE("SR3", 
  1137.  "System restart test. Focus on testing restart from withn"
  1138.  "not all nodes alive when system went downn"
  1139.  "* 1. Load datan"
  1140.  "* 2. Restart 1 node -nostartn"
  1141.  "* 3. Update recordsn"
  1142.  "* 4. Restart cluster and verify recordsn"
  1143.  "* 5. Restart 1 node -nostartn"
  1144.  "* 6. Delete half of the recordsn"
  1145.  "* 7. Restart cluster and verify recordsn"
  1146.  "* 8. Restart 1 node -nostartn"
  1147.  "* 9. Delete all recordsn"
  1148.  "* 10. Restart cluster and verify recordsn"){
  1149.   INITIALIZER(runWaitStarted);
  1150.   STEP(runSystemRestart3);
  1151.   FINALIZER(runClearTable);
  1152. }
  1153. TESTCASE("SR4", 
  1154.  "System restart test. Focus on testing restart from withn"
  1155.  "not all nodes alive when system went down but running LCP atn"
  1156.  "high speed so that sometimes a TO is required to start clustern"
  1157.  "* 1. Load datan"
  1158.  "* 2. Restart 1 node -nostartn"
  1159.  "* 3. Update recordsn"
  1160.  "* 4. Restart cluster and verify recordsn"
  1161.  "* 5. Restart 1 node -nostartn"
  1162.  "* 6. Delete half of the recordsn"
  1163.  "* 7. Restart cluster and verify recordsn"
  1164.  "* 8. Restart 1 node -nostartn"
  1165.  "* 9. Delete all recordsn"
  1166.  "* 10. Restart cluster and verify recordsn"){
  1167.   INITIALIZER(runWaitStarted);
  1168.   STEP(runSystemRestart4);
  1169.   FINALIZER(runClearTable);
  1170. }
  1171. TESTCASE("SR5", 
  1172.  "As SR4 but making restart abortsn"
  1173.  "* 1. Load datan"
  1174.  "* 2. Restart 1 node -nostartn"
  1175.  "* 3. Update recordsn"
  1176.  "* 4. Restart cluster and verify recordsn"
  1177.  "* 5. Restart 1 node -nostartn"
  1178.  "* 6. Delete half of the recordsn"
  1179.  "* 7. Restart cluster and verify recordsn"
  1180.  "* 8. Restart 1 node -nostartn"
  1181.  "* 9. Delete all recordsn"
  1182.  "* 10. Restart cluster and verify recordsn"){
  1183.   INITIALIZER(runWaitStarted);
  1184.   STEP(runSystemRestart5);
  1185.   FINALIZER(runClearTable);
  1186. }
  1187. TESTCASE("SR6", 
  1188.  "Perform system restart with some nodes having FS others wo/n"
  1189.  "* 1. Load datan"
  1190.  "* 2. Restart all node -nostartn"
  1191.  "* 3. Restart some nodes -i -nostartn"
  1192.  "* 4. Start all nodes verify recordsn"){
  1193.   INITIALIZER(runWaitStarted);
  1194.   INITIALIZER(runClearTable);
  1195.   STEP(runSystemRestart6);
  1196.   FINALIZER(runClearTable);
  1197. }
  1198. TESTCASE("SR7", 
  1199.  "Perform partition win system restartn"
  1200.  "* 1. Load datan"
  1201.  "* 2. Restart all node -nostartn"
  1202.  "* 3. Start all but one noden"
  1203.  "* 4. Verify recordsn"
  1204.  "* 5. Start last noden"
  1205.  "* 6. Verify recordsn"){
  1206.   INITIALIZER(runWaitStarted);
  1207.   INITIALIZER(runClearTable);
  1208.   STEP(runSystemRestart7);
  1209.   FINALIZER(runClearTable);
  1210. }
  1211. TESTCASE("SR8", 
  1212.  "Perform partition win system restart with other nodes delayedn"
  1213.  "* 1. Load datan"
  1214.  "* 2. Restart all node -nostartn"
  1215.  "* 3. Start all but one noden"
  1216.  "* 4. Wait for startphase >= 2n"
  1217.  "* 5. Start last noden"
  1218.  "* 6. Verify recordsn"){
  1219.   INITIALIZER(runWaitStarted);
  1220.   INITIALIZER(runClearTable);
  1221.   STEP(runSystemRestart8);
  1222.   FINALIZER(runClearTable);
  1223. }
  1224. TESTCASE("SR9", 
  1225.  "Perform partition win system restart with other nodes delayedn"
  1226.  "* 1. Start transactionn"
  1227.  "* 2. insert (1,1)n"
  1228.  "* 3. update (1,2)n"
  1229.  "* 4. start lcpn"
  1230.  "* 5. commitn"
  1231.  "* 6. restartn"){
  1232.   INITIALIZER(runWaitStarted);
  1233.   INITIALIZER(runClearTable);
  1234.   STEP(runSystemRestart9);
  1235.   FINALIZER(runClearTable);
  1236. }
  1237. NDBT_TESTSUITE_END(testSystemRestart);
  1239. int main(int argc, const char** argv){
  1240.   ndb_init();
  1241.   return testSystemRestart.execute(argc, argv);
  1242. }