leveldb::FaultInjectionTestEnv Class Reference

Inheritance diagram for leveldb::FaultInjectionTestEnv:

Collaboration diagram for leveldb::FaultInjectionTestEnv:

Public Member Functions
	FaultInjectionTestEnv ()
virtual	~FaultInjectionTestEnv ()
virtual Status	NewWritableFile (const std::string &fname, WritableFile **result)
virtual Status	NewAppendableFile (const std::string &fname, WritableFile **result)
virtual Status	DeleteFile (const std::string &f)
virtual Status	RenameFile (const std::string &s, const std::string &t)
void	WritableFileClosed (const FileState &state)
Status	DropUnsyncedFileData ()
Status	DeleteFilesCreatedAfterLastDirSync ()
void	DirWasSynced ()
bool	IsFileCreatedSinceLastDirSync (const std::string &filename)
void	ResetState ()
void	UntrackFile (const std::string &f)
bool	IsFilesystemActive () const
void	SetFilesystemActive (bool active)
Public Member Functions inherited from leveldb::EnvWrapper
	EnvWrapper (Env *t)
virtual	~EnvWrapper ()
Env *	target () const
Status	NewSequentialFile (const std::string &f, SequentialFile **r)
Status	NewRandomAccessFile (const std::string &f, RandomAccessFile **r)
Status	NewWritableFile (const std::string &f, WritableFile **r)
Status	NewAppendableFile (const std::string &f, WritableFile **r)
bool	FileExists (const std::string &f)
Status	GetChildren (const std::string &dir, std::vector< std::string > *r)
Status	DeleteFile (const std::string &f)
Status	CreateDir (const std::string &d)
Status	DeleteDir (const std::string &d)
Status	GetFileSize (const std::string &f, uint64_t *s)
Status	RenameFile (const std::string &s, const std::string &t)
Status	LockFile (const std::string &f, FileLock **l)
Status	UnlockFile (FileLock *l)
void	Schedule (void(*f)(void *), void *a)
void	StartThread (void(*f)(void *), void *a)
virtual Status	GetTestDirectory (std::string *path)
virtual Status	NewLogger (const std::string &fname, Logger **result)
uint64_t	NowMicros ()
void	SleepForMicroseconds (int micros)
Public Member Functions inherited from leveldb::Env
	Env ()
virtual	~Env ()
virtual void	Schedule (void(*function)(void *arg), void *arg)=0
virtual void	StartThread (void(*function)(void *arg), void *arg)=0

Private Attributes
port::Mutex	mutex_
std::map< std::string, FileState >	db_file_state_
std::set< std::string >	new_files_since_last_dir_sync_
bool	filesystem_active_

Additional Inherited Members
Static Public Member Functions inherited from leveldb::Env
static Env *	Default ()

Detailed Description

Definition at line 127 of file fault_injection_test.cc.

Constructor & Destructor Documentation

FaultInjectionTestEnv()

leveldb::FaultInjectionTestEnv::FaultInjectionTestEnv ( )

inline

Definition at line 129 of file fault_injection_test.cc.

: EnvWrapper(Env::Default()), filesystem_active_(true) {}

~FaultInjectionTestEnv()

virtual leveldb::FaultInjectionTestEnv::~FaultInjectionTestEnv ( )

inlinevirtual

Definition at line 130 of file fault_injection_test.cc.

{ }

Here is the call graph for this function:

Member Function Documentation

DeleteFile()

Status leveldb::FaultInjectionTestEnv::DeleteFile ( const std::string &  f )

virtual

Implements leveldb::Env.

Definition at line 297 of file fault_injection_test.cc.

                                                           {
  Status s = EnvWrapper::DeleteFile(f);
  ASSERT_OK(s);
  if (s.ok()) {
    UntrackFile(f);
  }
  return s;
}

Here is the call graph for this function:

Here is the caller graph for this function:

DeleteFilesCreatedAfterLastDirSync()

Status leveldb::FaultInjectionTestEnv::DeleteFilesCreatedAfterLastDirSync

(

)

Definition at line 335 of file fault_injection_test.cc.

                                                                 {
  // Because DeleteFile access this container make a copy to avoid deadlock
  mutex_.Lock();
  std::set<std::string> new_files(new_files_since_last_dir_sync_.begin(),
                                  new_files_since_last_dir_sync_.end());
  mutex_.Unlock();
  Status s;
  std::set<std::string>::const_iterator it;
  for (it = new_files.begin(); s.ok() && it != new_files.end(); ++it) {
    s = DeleteFile(*it);
  }
  return s;
}

Here is the call graph for this function:

Here is the caller graph for this function:

DirWasSynced()

void leveldb::FaultInjectionTestEnv::DirWasSynced

(

)

Definition at line 279 of file fault_injection_test.cc.

                                         {
  MutexLock l(&mutex_);
  new_files_since_last_dir_sync_.clear();
}

Here is the caller graph for this function:

DropUnsyncedFileData()

Status leveldb::FaultInjectionTestEnv::DropUnsyncedFileData

(

)

Definition at line 265 of file fault_injection_test.cc.

                                                   {
  Status s;
  MutexLock l(&mutex_);
  for (std::map<std::string, FileState>::const_iterator it =
           db_file_state_.begin();
       s.ok() && it != db_file_state_.end(); ++it) {
    const FileState& state = it->second;
    if (!state.IsFullySynced()) {
      s = state.DropUnsyncedData();
    }
  }
  return s;
}

Here is the call graph for this function:

Here is the caller graph for this function:

IsFileCreatedSinceLastDirSync()

bool leveldb::FaultInjectionTestEnv::IsFileCreatedSinceLastDirSync

(

const std::string &

filename

)

Definition at line 284 of file fault_injection_test.cc.

                               {
  MutexLock l(&mutex_);
  return new_files_since_last_dir_sync_.find(filename) !=
         new_files_since_last_dir_sync_.end();
}

Here is the caller graph for this function:

IsFilesystemActive()

bool leveldb::FaultInjectionTestEnv::IsFilesystemActive ( ) const

inline

Definition at line 149 of file fault_injection_test.cc.

{ return filesystem_active_; }

Here is the caller graph for this function:

NewAppendableFile()

Status leveldb::FaultInjectionTestEnv::NewAppendableFile ( const std::string &  fname, WritableFile **  result  )

virtual

Reimplemented from leveldb::Env.

Definition at line 245 of file fault_injection_test.cc.

                                                                       {
  WritableFile* actual_writable_file;
  Status s = target()->NewAppendableFile(fname, &actual_writable_file);
  if (s.ok()) {
    FileState state(fname);
    state.pos_ = 0;
    {
      MutexLock l(&mutex_);
      if (db_file_state_.count(fname) == 0) {
        new_files_since_last_dir_sync_.insert(fname);
      } else {
        state = db_file_state_[fname];
      }
    }
    *result = new TestWritableFile(state, actual_writable_file, this);
  }
  return s;
}

Here is the call graph for this function:

Here is the caller graph for this function:

NewWritableFile()

Status leveldb::FaultInjectionTestEnv::NewWritableFile ( const std::string &  fname, WritableFile **  result  )

virtual

Implements leveldb::Env.

Definition at line 227 of file fault_injection_test.cc.

                                                                     {
  WritableFile* actual_writable_file;
  Status s = target()->NewWritableFile(fname, &actual_writable_file);
  if (s.ok()) {
    FileState state(fname);
    state.pos_ = 0;
    *result = new TestWritableFile(state, actual_writable_file, this);
    // NewWritableFile doesn't append to files, so if the same file is
    // opened again then it will be truncated - so forget our saved
    // state.
    UntrackFile(fname);
    MutexLock l(&mutex_);
    new_files_since_last_dir_sync_.insert(fname);
  }
  return s;
}

Here is the call graph for this function:

Here is the caller graph for this function:

RenameFile()

Status leveldb::FaultInjectionTestEnv::RenameFile ( const std::string &  s, const std::string &  t  )

virtual

Implements leveldb::Env.

Definition at line 306 of file fault_injection_test.cc.

                                                             {
  Status ret = EnvWrapper::RenameFile(s, t);

  if (ret.ok()) {
    MutexLock l(&mutex_);
    if (db_file_state_.find(s) != db_file_state_.end()) {
      db_file_state_[t] = db_file_state_[s];
      db_file_state_.erase(s);
    }

    if (new_files_since_last_dir_sync_.erase(s) != 0) {
      assert(new_files_since_last_dir_sync_.find(t) ==
             new_files_since_last_dir_sync_.end());
      new_files_since_last_dir_sync_.insert(t);
    }
  }

  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ResetState()

void leveldb::FaultInjectionTestEnv::ResetState

(

)

Definition at line 327 of file fault_injection_test.cc.

                                       {
  // Since we are not destroying the database, the existing files
  // should keep their recorded synced/flushed state. Therefore
  // we do not reset db_file_state_ and new_files_since_last_dir_sync_.
  MutexLock l(&mutex_);
  SetFilesystemActive(true);
}

Here is the caller graph for this function:

SetFilesystemActive()

void leveldb::FaultInjectionTestEnv::SetFilesystemActive ( bool  active )

inline

Definition at line 150 of file fault_injection_test.cc.

{ filesystem_active_ = active; }

Here is the caller graph for this function:

UntrackFile()

void leveldb::FaultInjectionTestEnv::UntrackFile

(

const std::string &

f

)

Definition at line 291 of file fault_injection_test.cc.

                                                          {
  MutexLock l(&mutex_);
  db_file_state_.erase(f);
  new_files_since_last_dir_sync_.erase(f);
}

Here is the caller graph for this function:

WritableFileClosed()

void leveldb::FaultInjectionTestEnv::WritableFileClosed

(

const FileState &

state

)

Definition at line 349 of file fault_injection_test.cc.

                                                                     {
  MutexLock l(&mutex_);
  db_file_state_[state.filename_] = state;
}

Here is the caller graph for this function:

Member Data Documentation

db_file_state_

std::map<std::string, FileState> leveldb::FaultInjectionTestEnv::db_file_state_

private

Definition at line 154 of file fault_injection_test.cc.

filesystem_active_

bool leveldb::FaultInjectionTestEnv::filesystem_active_

private

Definition at line 156 of file fault_injection_test.cc.

mutex_

port::Mutex leveldb::FaultInjectionTestEnv::mutex_

private

Definition at line 153 of file fault_injection_test.cc.

new_files_since_last_dir_sync_

std::set<std::string> leveldb::FaultInjectionTestEnv::new_files_since_last_dir_sync_

private

Definition at line 155 of file fault_injection_test.cc.

---

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

• db/fault_injection_test.cc