mabain/src/unittest/backup_test.cpp

   1
   2 #include <stdio.h>
   3
   4 #include <unistd.h>
   5 #include <stdlib.h>
   6 #include <list>
   7 #include <cstdlib>
   8 #include <iostream>
   9 #include <gtest/gtest.h>
  10 #include <time.h>
  11
  12 #include "../db.h"
  13 #include "../mb_data.h"
  14 #include "../mb_backup.h"
  15 #include "../resource_pool.h"
  16 #include "./test_key.h"
  17
  18 #define MB_DIR "/var/tmp/mabain_test/"
  19 #define MB_BACKUP_DIR "/var/tmp/mabain_backup/"
  20 #define MB_BACKUP_DIR_2 "/var/tmp/mabain_backup_2/"
  21
  22 using namespace mabain;
  23
  24 namespace {
  25
  26 class BackupTest : public ::testing::Test
  27 {
  28 public:
  29     BackupTest() {
  30     }
  31     virtual ~BackupTest() {
  32     }
  33     virtual void SetUp()
  34     {
  35         std::string cmd_2 = std::string("mkdir -p ") + MB_DIR;
  36         std::string cmd = std::string("mkdir -p ") + MB_BACKUP_DIR;
  37         if(system(cmd_2.c_str())!= 0){
  38         }
  39         if(system(cmd.c_str()) != 0) {
  40         }
  41         cmd = std::string("rm ") + MB_DIR + "_*";
  42         std::string cmd_1 = std::string("rm ") + MB_BACKUP_DIR + "_*";
  43         if(system(cmd.c_str()) != 0){
  44         }
  45         if(system(cmd_1.c_str()) != 0){
  46         }
  47         cmd = std::string("mkdir -p ") + MB_BACKUP_DIR_2;
  48         if(system(cmd.c_str()) != 0){
  49         }
  50         cmd = std::string("rm  ") + MB_BACKUP_DIR_2 + "_*";
  51         if(system(cmd.c_str()) != 0){
  52         }
  53
  54     }
  55     virtual void TearDown() {
  56         ResourcePool::getInstance().RemoveAll();
  57     }
  58
  59     void check_overwritten_keys(DB *db_bkp, int num)
  60     {
  61         TestKey tkey(MABAIN_TEST_KEY_TYPE_INT);
  62         TestKey tkey1(MABAIN_TEST_KEY_TYPE_SHA_128);
  63         std::string key;
  64         int rval;
  65         for(int i = 0; i < num; i++)
  66         {
  67             MBData mbd;
  68             key = tkey.get_key(i);
  69             rval = db_bkp->Find(key, mbd);
  70             EXPECT_EQ(rval, MBError::SUCCESS);
  71             EXPECT_EQ(std::string((const char*)mbd.buff, mbd.data_len)==key+"_new", true);
  72             key = tkey1.get_key(i);
  73             rval = db_bkp->Find(key, mbd);
  74             EXPECT_EQ(rval, MBError::SUCCESS);
  75             EXPECT_EQ(std::string((const char*)mbd.buff, mbd.data_len)==key+"_new", true);
  76         }
  77     }
  78
  79
  80 protected:
  81 };
  82
  83
  84 TEST_F(BackupTest, Create_backup_db)
  85 {
  86     TestKey tkey(MABAIN_TEST_KEY_TYPE_INT);
  87     TestKey tkey1(MABAIN_TEST_KEY_TYPE_SHA_128);
  88     int num = 10;
  89     std::string key;
  90     int rval;
  91     DB *db = new DB(MB_DIR, CONSTS::WriterOptions());
  92     assert(db->is_open());
  93     for(int i = 0; i < num; i++)
  94     {
  95         key = tkey.get_key(i);
  96         rval = db->Add(key, key);
  97         EXPECT_EQ(rval, MBError::SUCCESS);
  98         key = tkey1.get_key(i);
  99         rval = db->Add(key, key);
 100         EXPECT_EQ(rval, MBError::SUCCESS);
 101     }
 102
 103     clock_t t;
 104     t = clock();
 105
 106     try
 107     {
 108         DBBackup bk(*db);
 109         rval = bk.Backup(MB_BACKUP_DIR);
 110     }
 111     catch (int error)
 112     {
 113         std::cout << "Backup failed "<< MBError::get_error_str(error) <<"\n";
 114         rval = error;
 115
 116     }
 117     EXPECT_EQ(rval, MBError::SUCCESS);
 118     t = clock() -t;
 119     printf ("It took me %ld clicks (%f seconds).\n",t,((float)t)/CLOCKS_PER_SEC);
 120     DB *db_bkp = new DB(MB_BACKUP_DIR, CONSTS::WriterOptions());
 121
 122     //Test to check already inserted key.
 123     for(int i = 0; i < num; i++)
 124     {
 125         key = tkey.get_key(i);
 126         rval = db_bkp->Add(key, key);
 127         EXPECT_EQ(rval, MBError::IN_DICT);
 128         key = tkey1.get_key(i);
 129         rval = db_bkp->Add(key, key);
 130         EXPECT_EQ(rval, MBError::IN_DICT);
 131     }
 132
 133     //Test to overwrite existing key and retrive it.
 134     for(int i = 0; i < num; i++)
 135     {
 136         key = tkey.get_key(i);
 137         rval = db_bkp->Add(key, key+"_new", true);
 138         EXPECT_EQ(rval, MBError::SUCCESS);
 139         key = tkey1.get_key(i);
 140         rval = db_bkp->Add(key, key+"_new", true);
 141     }
 142
 143     // Retrive the overwritten key and check it.
 144     check_overwritten_keys(db_bkp, num);
 145
 146     db_bkp->Close();
 147     delete db_bkp;
 148     //Asycwriter DB backup test
 149     db_bkp = new DB(MB_BACKUP_DIR, CONSTS::WriterOptions() | CONSTS::ASYNC_WRITER_MODE, 128LL*1024*1024, 128LL*1024*1024);
 150     assert(db_bkp->is_open());
 151 #ifndef __SHM_QUEUE__
 152     assert(db_bkp->AsyncWriterEnabled());
 153 #endif
 154     DB *db_r = new DB(MB_BACKUP_DIR, CONSTS::ReaderOptions(), 128LL*1024*1024, 128LL*1024*1024);
 155     assert(db_r->is_open());
 156 #ifndef __SHM_QUEUE__
 157     assert(db_r->SetAsyncWriterPtr(db_bkp) == MBError::SUCCESS);
 158     assert(db_r->AsyncWriterEnabled());
 159 #endif
 160     rval = db_r->Backup(MB_BACKUP_DIR_2);
 161     EXPECT_EQ(rval, MBError::SUCCESS);
 162     while (db_r->AsyncWriterBusy()) {
 163         usleep(10000);
 164     }
 165 #ifndef __SHM_QUEUE__
 166     assert(db_r->UnsetAsyncWriterPtr(db_bkp) == MBError::SUCCESS);
 167 #endif
 168     db_r->Close();
 169     db_bkp->Close();
 170     delete db_r;
 171     delete db_bkp;
 172     db_bkp = new DB(MB_BACKUP_DIR_2, CONSTS::WriterOptions(), 128LL*1024*1024, 128LL*1024*1024);
 173     check_overwritten_keys(db_bkp, num);
 174
 175     //Test to remove all the keys from the DB.
 176     rval = db_bkp->RemoveAll();
 177     EXPECT_EQ(rval, MBError::SUCCESS);
 178     EXPECT_EQ(0, db_bkp->Count());
 179     db_bkp->Close();
 180     delete db_bkp;
 181
 182     db->Close();
 183     delete db;
 184 }
 185 }