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

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

MySQL数据库

开发平台：

Visual C++

testBackup.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 <NdbBackup.hpp>
  24. #define CHECK(b) if (!(b)) { 
  25.   g_err << "ERR: "<< step->getName() 
  26.          << " failed on line " << __LINE__ << endl; 
  27.   result = NDBT_FAILED; 
  28.   continue; } 
  31. int runLoadTable(NDBT_Context* ctx, NDBT_Step* step){
  33.   int records = ctx->getNumRecords();
  34.   HugoTransactions hugoTrans(*ctx->getTab());
  35.   if (hugoTrans.loadTable(GETNDB(step), records) != 0){
  36.     return NDBT_FAILED;
  37.   }
  38.   return NDBT_OK;
  39. }
  41. bool testMaster = true;
  42. bool testSlave = false;
  44. int setMaster(NDBT_Context* ctx, NDBT_Step* step){
  45.   testMaster = true;
  46.   testSlave = false;
  47.   return NDBT_OK;
  48. }
  49. int setMasterAsSlave(NDBT_Context* ctx, NDBT_Step* step){
  50.   testMaster = true;
  51.   testSlave = true;
  52.   return NDBT_OK;
  53. }
  54. int setSlave(NDBT_Context* ctx, NDBT_Step* step){
  55.   testMaster = false;
  56.   testSlave = true;
  57.   return NDBT_OK;
  58. }
  60. int runAbort(NDBT_Context* ctx, NDBT_Step* step){
  61.   NdbBackup backup(GETNDB(step)->getNodeId()+1);
  63.   NdbRestarter restarter;
  65.   if (restarter.getNumDbNodes() < 2){
  66.     ctx->stopTest();
  67.     return NDBT_OK;
  68.   }
  70.   if(restarter.waitClusterStarted(60) != 0){
  71.     g_err << "Cluster failed to start" << endl;
  72.     return NDBT_FAILED;
  73.   }
  75.   if (testMaster) {
  76.     if (testSlave) {
  77.       if (backup.NFMasterAsSlave(restarter) != NDBT_OK){
  78. return NDBT_FAILED;
  79.       }
  80.     } else {
  81.       if (backup.NFMaster(restarter) != NDBT_OK){
  82. return NDBT_FAILED;
  83.       }
  84.     }
  85.   } else {
  86.     if (backup.NFSlave(restarter) != NDBT_OK){
  87.       return NDBT_FAILED;
  88.     }
  89.   }
  90.   
  91.   return NDBT_OK;
  92. }
  94. int runFail(NDBT_Context* ctx, NDBT_Step* step){
  95.   NdbBackup backup(GETNDB(step)->getNodeId()+1);
  97.   NdbRestarter restarter;
  99.   if (restarter.getNumDbNodes() < 2){
  100.     ctx->stopTest();
  101.     return NDBT_OK;
  102.   }
  104.   if(restarter.waitClusterStarted(60) != 0){
  105.     g_err << "Cluster failed to start" << endl;
  106.     return NDBT_FAILED;
  107.   }
  109.   if (testMaster) {
  110.     if (testSlave) {
  111.       if (backup.FailMasterAsSlave(restarter) != NDBT_OK){
  112. return NDBT_FAILED;
  113.       }
  114.     } else {
  115.       if (backup.FailMaster(restarter) != NDBT_OK){
  116. return NDBT_FAILED;
  117.       }
  118.     }
  119.   } else {
  120.     if (backup.FailSlave(restarter) != NDBT_OK){
  121.       return NDBT_FAILED;
  122.     }
  123.   }
  125.   return NDBT_OK;
  126. }
  128. int runBackupOne(NDBT_Context* ctx, NDBT_Step* step){
  129.   NdbBackup backup(GETNDB(step)->getNodeId()+1);
  130.   unsigned backupId = 0;
  132.   if (backup.start(backupId) == -1){
  133.     return NDBT_FAILED;
  134.   }
  135.   ndbout << "Started backup " << backupId << endl;
  136.   ctx->setProperty("BackupId", backupId);
  138.   return NDBT_OK;
  139. }
  141. int
  142. runBackupLoop(NDBT_Context* ctx, NDBT_Step* step){
  143.   NdbBackup backup(GETNDB(step)->getNodeId()+1);
  144.   unsigned backupId = 0;
  145.   
  146.   int loops = ctx->getNumLoops();
  147.   while(!ctx->isTestStopped() && loops--)
  148.   {
  149.     if (backup.start(backupId) == -1)
  150.     {
  151.       sleep(1);
  152.       loops++;
  153.     }
  154.     else
  155.     {
  156.       sleep(3);
  157.     }
  158.   }
  160.   ctx->stopTest();
  161.   return NDBT_OK;
  162. }
  164. int
  165. runDDL(NDBT_Context* ctx, NDBT_Step* step){
  166.   Ndb* pNdb= GETNDB(step);
  167.   NdbDictionary::Dictionary* pDict = pNdb->getDictionary();
  168.   
  169.   const int tables = NDBT_Tables::getNumTables();
  170.   while(!ctx->isTestStopped())
  171.   {
  172.     const int tab_no = rand() % (tables);
  173.     NdbDictionary::Table tab = *NDBT_Tables::getTable(tab_no);
  174.     BaseString name= tab.getName();
  175.     name.appfmt("-%d", step->getStepNo());
  176.     tab.setName(name.c_str());
  177.     if(pDict->createTable(tab) == 0)
  178.     {
  179.       HugoTransactions hugoTrans(* pDict->getTable(name.c_str()));
  180.       if (hugoTrans.loadTable(pNdb, 10000) != 0){
  181. return NDBT_FAILED;
  182.       }
  183.       
  184.       while(pDict->dropTable(tab.getName()) != 0 &&
  185.     pDict->getNdbError().code != 4009)
  186. g_err << pDict->getNdbError() << endl;
  187.       
  188.       sleep(1);
  190.     }
  191.   }
  192.   return NDBT_OK;
  193. }
  196. int runRestartInitial(NDBT_Context* ctx, NDBT_Step* step){
  197.   NdbRestarter restarter;
  199.   Ndb* pNdb = GETNDB(step);
  201.   const NdbDictionary::Table *tab = ctx->getTab();
  202.   pNdb->getDictionary()->dropTable(tab->getName());
  204.   if (restarter.restartAll(true) != 0)
  205.     return NDBT_FAILED;
  207.   if (restarter.waitClusterStarted() != 0)
  208.     return NDBT_FAILED;
  209.   
  210.   return NDBT_OK;
  211. }
  213. int runRestoreOne(NDBT_Context* ctx, NDBT_Step* step){
  214.   NdbBackup backup(GETNDB(step)->getNodeId()+1);
  215.   unsigned backupId = ctx->getProperty("BackupId"); 
  217.   ndbout << "Restoring backup " << backupId << endl;
  219.   if (backup.restore(backupId) == -1){
  220.     return NDBT_FAILED;
  221.   }
  223.   return NDBT_OK;
  224. }
  226. int runVerifyOne(NDBT_Context* ctx, NDBT_Step* step){
  227.   int records = ctx->getNumRecords();
  228.   Ndb* pNdb = GETNDB(step);
  229.   int result = NDBT_OK;
  230.   int count = 0;
  232.   ndbout << *(const NDBT_Table*)ctx->getTab() << endl;
  234.   UtilTransactions utilTrans(*ctx->getTab());
  235.   HugoTransactions hugoTrans(*ctx->getTab());
  237.   do{
  239.     // Check that there are as many records as we expected
  240.     CHECK(utilTrans.selectCount(pNdb, 64, &count) == 0);
  242.     g_err << "count = " << count;
  243.     g_err << " records = " << records;
  244.     g_err << endl;
  246.     CHECK(count == records);
  248.     // Read and verify every record
  249.     CHECK(hugoTrans.pkReadRecords(pNdb, records) == 0);
  250.     
  251.   } while (false);
  253.   return result;
  254. }
  256. int runClearTable(NDBT_Context* ctx, NDBT_Step* step){
  257.   int records = ctx->getNumRecords();
  258.   
  259.   UtilTransactions utilTrans(*ctx->getTab());
  260.   if (utilTrans.clearTable2(GETNDB(step),  records) != 0){
  261.     return NDBT_FAILED;
  262.   }
  263.   return NDBT_OK;
  264. }
  266. int runDropTable(NDBT_Context* ctx, NDBT_Step* step){
  267.   GETNDB(step)->getDictionary()->dropTable(ctx->getTab()->getName());
  268.   return NDBT_OK;
  269. }
  271. #include "bank/Bank.hpp"
  273. int runCreateBank(NDBT_Context* ctx, NDBT_Step* step){
  274.   Bank bank;
  275.   int overWriteExisting = true;
  276.   if (bank.createAndLoadBank(overWriteExisting, 10) != NDBT_OK)
  277.     return NDBT_FAILED;
  278.   return NDBT_OK;
  279. }
  281. int runBankTimer(NDBT_Context* ctx, NDBT_Step* step){
  282.   Bank bank;
  283.   int wait = 30; // Max seconds between each "day"
  284.   int yield = 1; // Loops before bank returns 
  286.   while (ctx->isTestStopped() == false) {
  287.     bank.performIncreaseTime(wait, yield);
  288.   }
  289.   return NDBT_OK;
  290. }
  292. int runBankTransactions(NDBT_Context* ctx, NDBT_Step* step){
  293.   Bank bank;
  294.   int wait = 10; // Max ms between each transaction
  295.   int yield = 100; // Loops before bank returns 
  297.   while (ctx->isTestStopped() == false) {
  298.     bank.performTransactions(wait, yield);
  299.   }
  300.   return NDBT_OK;
  301. }
  303. int runBankGL(NDBT_Context* ctx, NDBT_Step* step){
  304.   Bank bank;
  305.   int yield = 20; // Loops before bank returns 
  306.   int result = NDBT_OK;
  308.   while (ctx->isTestStopped() == false) {
  309.     if (bank.performMakeGLs(yield) != NDBT_OK){
  310.       ndbout << "bank.performMakeGLs FAILED" << endl;
  311.       result = NDBT_FAILED;
  312.     }
  313.   }
  314.   return NDBT_OK;
  315. }
  317. int runBankSum(NDBT_Context* ctx, NDBT_Step* step){
  318.   Bank bank;
  319.   int wait = 2000; // Max ms between each sum of accounts
  320.   int yield = 1; // Loops before bank returns 
  321.   int result = NDBT_OK;
  323.   while (ctx->isTestStopped() == false) {
  324.     if (bank.performSumAccounts(wait, yield) != NDBT_OK){
  325.       ndbout << "bank.performSumAccounts FAILED" << endl;
  326.       result = NDBT_FAILED;
  327.     }
  328.   }
  329.   return result ;
  330. }
  332. int runDropBank(NDBT_Context* ctx, NDBT_Step* step){
  333.   Bank bank;
  334.   if (bank.dropBank() != NDBT_OK)
  335.     return NDBT_FAILED;
  336.   return NDBT_OK;
  337. }
  339. int runBackupBank(NDBT_Context* ctx, NDBT_Step* step){
  340.   int loops = ctx->getNumLoops();
  341.   int l = 0;
  342.   int maxSleep = 30; // Max seconds between each backup
  343.   Ndb* pNdb = GETNDB(step);
  344.   NdbBackup backup(GETNDB(step)->getNodeId()+1);
  345.   unsigned minBackupId = ~0;
  346.   unsigned maxBackupId = 0;
  347.   unsigned backupId = 0;
  348.   int result = NDBT_OK;
  350.   while (l < loops && result != NDBT_FAILED){
  352.     if (pNdb->waitUntilReady() != 0){
  353.       result = NDBT_FAILED;
  354.       continue;
  355.     }
  357.     // Sleep for a while
  358.     NdbSleep_SecSleep(maxSleep);
  359.     
  360.     // Perform backup
  361.     if (backup.start(backupId) != 0){
  362.       ndbout << "backup.start failed" << endl;
  363.       result = NDBT_FAILED;
  364.       continue;
  365.     }
  366.     ndbout << "Started backup " << backupId << endl;
  368.     // Remember min and max backupid
  369.     if (backupId < minBackupId)
  370.       minBackupId = backupId;
  372.     if (backupId > maxBackupId)
  373.       maxBackupId = backupId;
  374.     
  375.     ndbout << " maxBackupId = " << maxBackupId 
  376.    << ", minBackupId = " << minBackupId << endl;
  377.     ctx->setProperty("MinBackupId", minBackupId);    
  378.     ctx->setProperty("MaxBackupId", maxBackupId);    
  379.     
  380.     l++;
  381.   }
  383.   ctx->stopTest();
  385.   return result;
  386. }
  388. int runRestoreBankAndVerify(NDBT_Context* ctx, NDBT_Step* step){
  389.   NdbRestarter restarter;
  390.   NdbBackup backup(GETNDB(step)->getNodeId()+1);
  391.   unsigned minBackupId = ctx->getProperty("MinBackupId");
  392.   unsigned maxBackupId = ctx->getProperty("MaxBackupId");
  393.   unsigned backupId = minBackupId;
  394.   int result = NDBT_OK;
  395.   int errSumAccounts = 0;
  396.   int errValidateGL = 0;
  398.   ndbout << " maxBackupId = " << maxBackupId << endl;
  399.   ndbout << " minBackupId = " << minBackupId << endl;
  400.   
  401.   while (backupId <= maxBackupId){
  403.     // TEMPORARY FIX
  404.     // To erase all tables from cache(s)
  405.     // To be removed, maybe replaced by ndb.invalidate();
  406.     {
  407.       Bank bank;
  408.       
  409.       if (bank.dropBank() != NDBT_OK){
  410. result = NDBT_FAILED;
  411. break;
  412.       }
  413.     }
  414.     // END TEMPORARY FIX
  416.     ndbout << "Performing initial restart" << endl;
  417.     if (restarter.restartAll(true) != 0)
  418.       return NDBT_FAILED;
  420.     if (restarter.waitClusterStarted() != 0)
  421.       return NDBT_FAILED;
  423.     ndbout << "Restoring backup " << backupId << endl;
  424.     if (backup.restore(backupId) == -1){
  425.       return NDBT_FAILED;
  426.     }
  427.     ndbout << "Backup " << backupId << " restored" << endl;
  429.     // Let bank verify
  430.     Bank bank;
  432.     int wait = 0;
  433.     int yield = 1;
  434.     if (bank.performSumAccounts(wait, yield) != 0){
  435.       ndbout << "bank.performSumAccounts FAILED" << endl;
  436.       ndbout << "  backupId = " << backupId << endl << endl;
  437.       result = NDBT_FAILED;
  438.       errSumAccounts++;
  439.     }
  441.     if (bank.performValidateAllGLs() != 0){
  442.       ndbout << "bank.performValidateAllGLs FAILED" << endl;
  443.       ndbout << "  backupId = " << backupId << endl << endl;
  444.       result = NDBT_FAILED;
  445.       errValidateGL++;
  446.     }
  448.     backupId++;
  449.   }
  450.   
  451.   if (result != NDBT_OK){
  452.     ndbout << "Verification of backup failed" << endl
  453.    << "  errValidateGL="<<errValidateGL<<endl
  454.    << "  errSumAccounts="<<errSumAccounts<<endl << endl;
  455.   }
  456.   
  457.   return result;
  458. }
  460. NDBT_TESTSUITE(testBackup);
  461. TESTCASE("BackupOne", 
  462.  "Test that backup and restore works on one table n"
  463.  "1. Load tablen"
  464.  "2. Backupn"
  465.  "3. Restart -in"
  466.  "4. Restoren"
  467.  "5. Verify count and content of tablen"){
  468.   INITIALIZER(runLoadTable);
  469.   INITIALIZER(runBackupOne);
  470.   INITIALIZER(runRestartInitial);
  471.   INITIALIZER(runRestoreOne);
  472.   VERIFIER(runVerifyOne);
  473.   FINALIZER(runClearTable);
  474. }
  475. TESTCASE("BackupDDL", 
  476.  "Test that backup and restore works on with DDL ongoingn"
  477.  "1. Backups and DDL (create,drop,table.index)"){
  478.   INITIALIZER(runLoadTable);
  479.   STEP(runBackupLoop);
  480.   STEP(runDDL);
  481.   STEP(runDDL);
  482.   FINALIZER(runClearTable);
  483. }
  484. TESTCASE("BackupBank", 
  485.  "Test that backup and restore works during transaction loadn"
  486.  " by backing up the bank"
  487.  "1.  Create bankn"
  488.  "2a. Start bank and let it runn"
  489.  "2b. Perform loop number of backups of the bankn"
  490.  "    when backups are finished tell bank to closen"
  491.  "3.  Restart ndb -i and reload each backupn"
  492.  "    let bank verify that the backup is consistentn"
  493.  "4.  Drop bankn"){
  494.   INITIALIZER(runCreateBank);
  495.   STEP(runBankTimer);
  496.   STEP(runBankTransactions);
  497.   STEP(runBankTransactions);
  498.   STEP(runBankTransactions);
  499.   STEP(runBankTransactions);
  500.   STEP(runBankTransactions);
  501.   STEP(runBankTransactions);
  502.   STEP(runBankTransactions);
  503.   STEP(runBankTransactions);
  504.   STEP(runBankTransactions);
  505.   STEP(runBankTransactions);
  506.   STEP(runBankGL);
  507.   // TODO  STEP(runBankSum);
  508.   STEP(runBackupBank);
  509.   VERIFIER(runRestoreBankAndVerify);
  510.   //  FINALIZER(runDropBank);
  511. }
  512. TESTCASE("NFMaster", 
  513.  "Test that backup behaves during node failiuren"){
  514.   INITIALIZER(setMaster);
  515.   STEP(runAbort);
  517. }
  518. TESTCASE("NFMasterAsSlave", 
  519.  "Test that backup behaves during node failiuren"){
  520.   INITIALIZER(setMasterAsSlave);
  521.   STEP(runAbort);
  523. }
  524. TESTCASE("NFSlave", 
  525.  "Test that backup behaves during node failiuren"){
  526.   INITIALIZER(setSlave);
  527.   STEP(runAbort);
  529. }
  530. TESTCASE("FailMaster", 
  531.  "Test that backup behaves during node failiuren"){
  532.   INITIALIZER(setMaster);
  533.   STEP(runFail);
  535. }
  536. TESTCASE("FailMasterAsSlave", 
  537.  "Test that backup behaves during node failiuren"){
  538.   INITIALIZER(setMasterAsSlave);
  539.   STEP(runFail);
  541. }
  542. TESTCASE("FailSlave", 
  543.  "Test that backup behaves during node failiuren"){
  544.   INITIALIZER(setSlave);
  545.   STEP(runFail);
  547. }
  548. NDBT_TESTSUITE_END(testBackup);
  550. int main(int argc, const char** argv){
  551.   ndb_init();
  552.   return testBackup.execute(argc, argv);
  553. }