leveldb::FaultInjectionTest Class Reference

Collaboration diagram for leveldb::FaultInjectionTest:

Public Types
enum	ExpectedVerifResult { VAL_EXPECT_NO_ERROR, VAL_EXPECT_ERROR }
enum	ResetMethod { RESET_DROP_UNSYNCED_DATA, RESET_DELETE_UNSYNCED_FILES }

Public Member Functions
	FaultInjectionTest ()
	~FaultInjectionTest ()
void	ReuseLogs (bool reuse)
void	Build (int start_idx, int num_vals)
Status	ReadValue (int i, std::string *val) const
Status	Verify (int start_idx, int num_vals, ExpectedVerifResult expected) const
Slice	Key (int i, std::string *storage) const
Slice	Value (int k, std::string *storage) const
Status	OpenDB ()
void	CloseDB ()
void	DeleteAllData ()
void	ResetDBState (ResetMethod reset_method)
void	PartialCompactTestPreFault (int num_pre_sync, int num_post_sync)
void	PartialCompactTestReopenWithFault (ResetMethod reset_method, int num_pre_sync, int num_post_sync)
void	NoWriteTestPreFault ()
void	NoWriteTestReopenWithFault (ResetMethod reset_method)
void	DoTest ()

Public Attributes
FaultInjectionTestEnv *	env_
std::string	dbname_
Cache *	tiny_cache_
Options	options_
DB *	db_

Detailed Description

Definition at line 359 of file fault_injection_test.cc.

Member Enumeration Documentation

ExpectedVerifResult

enum leveldb::FaultInjectionTest::ExpectedVerifResult

Enumerator
VAL_EXPECT_NO_ERROR
VAL_EXPECT_ERROR

Definition at line 361 of file fault_injection_test.cc.

{ VAL_EXPECT_NO_ERROR, VAL_EXPECT_ERROR };

ResetMethod

enum leveldb::FaultInjectionTest::ResetMethod

Enumerator
RESET_DROP_UNSYNCED_DATA
RESET_DELETE_UNSYNCED_FILES

Definition at line 362 of file fault_injection_test.cc.

{ RESET_DROP_UNSYNCED_DATA, RESET_DELETE_UNSYNCED_FILES };

Constructor & Destructor Documentation

FaultInjectionTest()

leveldb::FaultInjectionTest::FaultInjectionTest ( )

inline

Definition at line 370 of file fault_injection_test.cc.

      : env_(new FaultInjectionTestEnv),
        tiny_cache_(NewLRUCache(100)),
        db_(NULL) {
    dbname_ = test::TmpDir() + "/fault_test";
    DestroyDB(dbname_, Options());  // Destroy any db from earlier run
    options_.reuse_logs = true;
    options_.env = env_;
    options_.paranoid_checks = true;
    options_.block_cache = tiny_cache_;
    options_.create_if_missing = true;
  }

Here is the call graph for this function:

~FaultInjectionTest()

leveldb::FaultInjectionTest::~FaultInjectionTest ( )

inline

Definition at line 383 of file fault_injection_test.cc.

                        {
    CloseDB();
    DestroyDB(dbname_, Options());
    delete tiny_cache_;
    delete env_;
  }

Here is the call graph for this function:

Member Function Documentation

Build()

void leveldb::FaultInjectionTest::Build ( int  start_idx, int  num_vals  )

inline

Definition at line 394 of file fault_injection_test.cc.

                                          {
    std::string key_space, value_space;
    WriteBatch batch;
    for (int i = start_idx; i < start_idx + num_vals; i++) {
      Slice key = Key(i, &key_space);
      batch.Clear();
      batch.Put(key, Value(i, &value_space));
      WriteOptions options;
      ASSERT_OK(db_->Write(options, &batch));
    }
  }

Here is the call graph for this function:

CloseDB()

void leveldb::FaultInjectionTest::CloseDB ( )

inline

Definition at line 457 of file fault_injection_test.cc.

                 {
    delete db_;
    db_ = NULL;
  }

DeleteAllData()

void leveldb::FaultInjectionTest::DeleteAllData ( )

inline

Definition at line 462 of file fault_injection_test.cc.

                       {
    Iterator* iter = db_->NewIterator(ReadOptions());
    WriteOptions options;
    for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
      ASSERT_OK(db_->Delete(WriteOptions(), iter->key()));
    }

    delete iter;
  }

Here is the call graph for this function:

DoTest()

void leveldb::FaultInjectionTest::DoTest ( )

inline

Definition at line 512 of file fault_injection_test.cc.

                {
    Random rnd(0);
    ASSERT_OK(OpenDB());
    for (size_t idx = 0; idx < kNumIterations; idx++) {
      int num_pre_sync = rnd.Uniform(kMaxNumValues);
      int num_post_sync = rnd.Uniform(kMaxNumValues);

      PartialCompactTestPreFault(num_pre_sync, num_post_sync);
      PartialCompactTestReopenWithFault(RESET_DROP_UNSYNCED_DATA,
                                        num_pre_sync,
                                        num_post_sync);

      NoWriteTestPreFault();
      NoWriteTestReopenWithFault(RESET_DROP_UNSYNCED_DATA);

      PartialCompactTestPreFault(num_pre_sync, num_post_sync);
      // No new files created so we expect all values since no files will be
      // dropped.
      PartialCompactTestReopenWithFault(RESET_DELETE_UNSYNCED_FILES,
                                        num_pre_sync + num_post_sync,
                                        0);

      NoWriteTestPreFault();
      NoWriteTestReopenWithFault(RESET_DELETE_UNSYNCED_FILES);
    }
  }

Here is the call graph for this function:

Key()

Slice leveldb::FaultInjectionTest::Key ( int  i, std::string *  storage  ) const

inline

Definition at line 437 of file fault_injection_test.cc.

                                             {
    char buf[100];
    snprintf(buf, sizeof(buf), "%016d", i);
    storage->assign(buf, strlen(buf));
    return Slice(*storage);
  }

NoWriteTestPreFault()

void leveldb::FaultInjectionTest::NoWriteTestPreFault ( )

inline

Definition at line 503 of file fault_injection_test.cc.

                             {
  }

NoWriteTestReopenWithFault()

void leveldb::FaultInjectionTest::NoWriteTestReopenWithFault ( ResetMethod  reset_method )

inline

Definition at line 506 of file fault_injection_test.cc.

                                                            {
    CloseDB();
    ResetDBState(reset_method);
    ASSERT_OK(OpenDB());
  }

OpenDB()

Status leveldb::FaultInjectionTest::OpenDB ( )

inline

Definition at line 450 of file fault_injection_test.cc.

                  {
    delete db_;
    db_ = NULL;
    env_->ResetState();
    return DB::Open(options_, dbname_, &db_);
  }

Here is the call graph for this function:

PartialCompactTestPreFault()

void leveldb::FaultInjectionTest::PartialCompactTestPreFault ( int  num_pre_sync, int  num_post_sync  )

inline

Definition at line 485 of file fault_injection_test.cc.

                                                                       {
    DeleteAllData();
    Build(0, num_pre_sync);
    db_->CompactRange(NULL, NULL);
    Build(num_pre_sync, num_post_sync);
  }

Here is the call graph for this function:

PartialCompactTestReopenWithFault()

void leveldb::FaultInjectionTest::PartialCompactTestReopenWithFault ( ResetMethod  reset_method, int  num_pre_sync, int  num_post_sync  )

inline

Definition at line 492 of file fault_injection_test.cc.

                                                            {
    env_->SetFilesystemActive(false);
    CloseDB();
    ResetDBState(reset_method);
    ASSERT_OK(OpenDB());
    ASSERT_OK(Verify(0, num_pre_sync, FaultInjectionTest::VAL_EXPECT_NO_ERROR));
    ASSERT_OK(Verify(num_pre_sync, num_post_sync, FaultInjectionTest::VAL_EXPECT_ERROR));
  }

Here is the call graph for this function:

ReadValue()

Status leveldb::FaultInjectionTest::ReadValue ( int  i, std::string *  val  ) const

inline

Definition at line 406 of file fault_injection_test.cc.

                                                {
    std::string key_space, value_space;
    Slice key = Key(i, &key_space);
    Value(i, &value_space);
    ReadOptions options;
    return db_->Get(options, key, val);
  }

Here is the call graph for this function:

ResetDBState()

void leveldb::FaultInjectionTest::ResetDBState ( ResetMethod  reset_method )

inline

Definition at line 472 of file fault_injection_test.cc.

                                              {
    switch (reset_method) {
      case RESET_DROP_UNSYNCED_DATA:
        ASSERT_OK(env_->DropUnsyncedFileData());
        break;
      case RESET_DELETE_UNSYNCED_FILES:
        ASSERT_OK(env_->DeleteFilesCreatedAfterLastDirSync());
        break;
      default:
        assert(false);
    }
  }

Here is the call graph for this function:

ReuseLogs()

void leveldb::FaultInjectionTest::ReuseLogs ( bool  reuse )

inline

Definition at line 390 of file fault_injection_test.cc.

                             {
    options_.reuse_logs = reuse;
  }

Value()

Slice leveldb::FaultInjectionTest::Value ( int  k, std::string *  storage  ) const

inline

Definition at line 445 of file fault_injection_test.cc.

                                               {
    Random r(k);
    return test::RandomString(&r, kValueSize, storage);
  }

Here is the call graph for this function:

Verify()

Status leveldb::FaultInjectionTest::Verify ( int  start_idx, int  num_vals, ExpectedVerifResult  expected  ) const

inline

Definition at line 414 of file fault_injection_test.cc.

                                                    {
    std::string val;
    std::string value_space;
    Status s;
    for (int i = start_idx; i < start_idx + num_vals && s.ok(); i++) {
      Value(i, &value_space);
      s = ReadValue(i, &val);
      if (expected == VAL_EXPECT_NO_ERROR) {
        if (s.ok()) {
          ASSERT_EQ(value_space, val);
        }
      } else if (s.ok()) {
        fprintf(stderr, "Expected an error at %d, but was OK\n", i);
        s = Status::IOError(dbname_, "Expected value error:");
      } else {
        s = Status::OK();  // An expected error
      }
    }
    return s;
  }

Here is the call graph for this function:

Member Data Documentation

db_

DB* leveldb::FaultInjectionTest::db_

Definition at line 368 of file fault_injection_test.cc.

dbname_

std::string leveldb::FaultInjectionTest::dbname_

Definition at line 365 of file fault_injection_test.cc.

env_

FaultInjectionTestEnv* leveldb::FaultInjectionTest::env_

Definition at line 364 of file fault_injection_test.cc.

options_

Options leveldb::FaultInjectionTest::options_

Definition at line 367 of file fault_injection_test.cc.

tiny_cache_

Cache* leveldb::FaultInjectionTest::tiny_cache_

Definition at line 366 of file fault_injection_test.cc.

---

The documentation for this class was generated from the following file:

• db/fault_injection_test.cc