Introduce FaultInjectionTestFS to test fault File system instead of Env (#6414)
Summary: In the current code base, we can use FaultInjectionTestEnv to simulate the env issue such as file write/read errors, which are used in most of the test. The PR https://github.com/facebook/rocksdb/issues/5761 introduce the File System as a new Env API. This PR implement the FaultInjectionTestFS, which can be used to simulate when File System has issues such as IO error. user can specify any IOStatus error as input, such that FS corresponding actions will return certain error to the caller. A set of ErrorHandlerFSTests are introduced for testing Pull Request resolved: https://github.com/facebook/rocksdb/pull/6414 Test Plan: pass make asan_check, pass error_handler_fs_test. Differential Revision: D20252421 Pulled By: zhichao-cao fbshipit-source-id: e922038f8ce7e6d1da329fd0bba7283c4b779a21main
Zhichao Cao
5 years ago
committed by
Facebook Github Bot
parent
8bbd76edbf
commit
e62fe50634
@ -0,0 +1,430 @@ |
||||
// Copyright (c) 2011-present, Facebook, Inc. All rights reserved.
|
||||
// This source code is licensed under both the GPLv2 (found in the
|
||||
// COPYING file in the root directory) and Apache 2.0 License
|
||||
// (found in the LICENSE.Apache file in the root directory).
|
||||
//
|
||||
// Copyright 2014 The LevelDB Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style license that can be
|
||||
// found in the LICENSE file. See the AUTHORS file for names of contributors.
|
||||
|
||||
// This test uses a custom FileSystem to keep track of the state of a file
|
||||
// system the last "Sync". The data being written is cached in a "buffer".
|
||||
// Only when "Sync" is called, the data will be persistent. It can similate
|
||||
// file data loss (or entire files) not protected by a "Sync". For any of the
|
||||
// FileSystem related operations, by specify the "IOStatus Error", a specific
|
||||
// error can be returned when file system is not activated.
|
||||
|
||||
#include "test_util/fault_injection_test_fs.h" |
||||
#include <functional> |
||||
#include <utility> |
||||
|
||||
namespace ROCKSDB_NAMESPACE { |
||||
|
||||
// Assume a filename, and not a directory name like "/foo/bar/"
|
||||
std::string TestFSGetDirName(const std::string filename) { |
||||
size_t found = filename.find_last_of("/\\"); |
||||
if (found == std::string::npos) { |
||||
return ""; |
||||
} else { |
||||
return filename.substr(0, found); |
||||
} |
||||
} |
||||
|
||||
// Trim the tailing "/" in the end of `str`
|
||||
std::string TestFSTrimDirname(const std::string& str) { |
||||
size_t found = str.find_last_not_of("/"); |
||||
if (found == std::string::npos) { |
||||
return str; |
||||
} |
||||
return str.substr(0, found + 1); |
||||
} |
||||
|
||||
// Return pair <parent directory name, file name> of a full path.
|
||||
std::pair<std::string, std::string> TestFSGetDirAndName( |
||||
const std::string& name) { |
||||
std::string dirname = TestFSGetDirName(name); |
||||
std::string fname = name.substr(dirname.size() + 1); |
||||
return std::make_pair(dirname, fname); |
||||
} |
||||
|
||||
IOStatus FSFileState::DropUnsyncedData() { |
||||
buffer_.resize(0); |
||||
return IOStatus::OK(); |
||||
} |
||||
|
||||
IOStatus FSFileState::DropRandomUnsyncedData(Random* rand) { |
||||
int range = static_cast<int>(buffer_.size()); |
||||
size_t truncated_size = static_cast<size_t>(rand->Uniform(range)); |
||||
buffer_.resize(truncated_size); |
||||
return IOStatus::OK(); |
||||
} |
||||
|
||||
IOStatus TestFSDirectory::Fsync(const IOOptions& options, IODebugContext* dbg) { |
||||
if (!fs_->IsFilesystemActive()) { |
||||
return fs_->GetError(); |
||||
} |
||||
fs_->SyncDir(dirname_); |
||||
return dir_->Fsync(options, dbg); |
||||
} |
||||
|
||||
TestFSWritableFile::TestFSWritableFile(const std::string& fname, |
||||
std::unique_ptr<FSWritableFile>&& f, |
||||
FaultInjectionTestFS* fs) |
||||
: state_(fname), |
||||
target_(std::move(f)), |
||||
writable_file_opened_(true), |
||||
fs_(fs) { |
||||
assert(target_ != nullptr); |
||||
state_.pos_ = 0; |
||||
} |
||||
|
||||
TestFSWritableFile::~TestFSWritableFile() { |
||||
if (writable_file_opened_) { |
||||
Close(IOOptions(), nullptr); |
||||
} |
||||
} |
||||
|
||||
IOStatus TestFSWritableFile::Append(const Slice& data, const IOOptions&, |
||||
IODebugContext*) { |
||||
MutexLock l(&mutex_); |
||||
if (!fs_->IsFilesystemActive()) { |
||||
return fs_->GetError(); |
||||
} |
||||
state_.buffer_.append(data.data(), data.size()); |
||||
state_.pos_ += data.size(); |
||||
fs_->WritableFileAppended(state_); |
||||
return IOStatus::OK(); |
||||
} |
||||
|
||||
IOStatus TestFSWritableFile::Close(const IOOptions& options, |
||||
IODebugContext* dbg) { |
||||
if (!fs_->IsFilesystemActive()) { |
||||
return fs_->GetError(); |
||||
} |
||||
writable_file_opened_ = false; |
||||
IOStatus io_s; |
||||
io_s = target_->Append(state_.buffer_, options, dbg); |
||||
if (io_s.ok()) { |
||||
state_.buffer_.resize(0); |
||||
target_->Sync(options, dbg); |
||||
io_s = target_->Close(options, dbg); |
||||
} |
||||
if (io_s.ok()) { |
||||
fs_->WritableFileClosed(state_); |
||||
} |
||||
return io_s; |
||||
} |
||||
|
||||
IOStatus TestFSWritableFile::Flush(const IOOptions&, IODebugContext*) { |
||||
if (!fs_->IsFilesystemActive()) { |
||||
return fs_->GetError(); |
||||
} |
||||
IOStatus io_s; |
||||
if (io_s.ok() && fs_->IsFilesystemActive()) { |
||||
state_.pos_at_last_flush_ = state_.pos_; |
||||
} |
||||
return io_s; |
||||
} |
||||
|
||||
IOStatus TestFSWritableFile::Sync(const IOOptions& options, |
||||
IODebugContext* dbg) { |
||||
if (!fs_->IsFilesystemActive()) { |
||||
return fs_->GetError(); |
||||
} |
||||
IOStatus io_s = target_->Append(state_.buffer_, options, dbg); |
||||
state_.buffer_.resize(0); |
||||
target_->Sync(options, dbg); |
||||
state_.pos_at_last_sync_ = state_.pos_; |
||||
fs_->WritableFileSynced(state_); |
||||
return io_s; |
||||
} |
||||
|
||||
TestFSRandomRWFile::TestFSRandomRWFile(const std::string& /*fname*/, |
||||
std::unique_ptr<FSRandomRWFile>&& f, |
||||
FaultInjectionTestFS* fs) |
||||
: target_(std::move(f)), file_opened_(true), fs_(fs) { |
||||
assert(target_ != nullptr); |
||||
} |
||||
|
||||
TestFSRandomRWFile::~TestFSRandomRWFile() { |
||||
if (file_opened_) { |
||||
Close(IOOptions(), nullptr); |
||||
} |
||||
} |
||||
|
||||
IOStatus TestFSRandomRWFile::Write(uint64_t offset, const Slice& data, |
||||
const IOOptions& options, |
||||
IODebugContext* dbg) { |
||||
if (!fs_->IsFilesystemActive()) { |
||||
return fs_->GetError(); |
||||
} |
||||
return target_->Write(offset, data, options, dbg); |
||||
} |
||||
|
||||
IOStatus TestFSRandomRWFile::Read(uint64_t offset, size_t n, |
||||
const IOOptions& options, Slice* result, |
||||
char* scratch, IODebugContext* dbg) const { |
||||
if (!fs_->IsFilesystemActive()) { |
||||
return fs_->GetError(); |
||||
} |
||||
return target_->Read(offset, n, options, result, scratch, dbg); |
||||
} |
||||
|
||||
IOStatus TestFSRandomRWFile::Close(const IOOptions& options, |
||||
IODebugContext* dbg) { |
||||
if (!fs_->IsFilesystemActive()) { |
||||
return fs_->GetError(); |
||||
} |
||||
file_opened_ = false; |
||||
return target_->Close(options, dbg); |
||||
} |
||||
|
||||
IOStatus TestFSRandomRWFile::Flush(const IOOptions& options, |
||||
IODebugContext* dbg) { |
||||
if (!fs_->IsFilesystemActive()) { |
||||
return fs_->GetError(); |
||||
} |
||||
return target_->Flush(options, dbg); |
||||
} |
||||
|
||||
IOStatus TestFSRandomRWFile::Sync(const IOOptions& options, |
||||
IODebugContext* dbg) { |
||||
if (!fs_->IsFilesystemActive()) { |
||||
return fs_->GetError(); |
||||
} |
||||
return target_->Sync(options, dbg); |
||||
} |
||||
|
||||
IOStatus FaultInjectionTestFS::NewDirectory( |
||||
const std::string& name, const IOOptions& options, |
||||
std::unique_ptr<FSDirectory>* result, IODebugContext* dbg) { |
||||
std::unique_ptr<FSDirectory> r; |
||||
IOStatus io_s = target()->NewDirectory(name, options, &r, dbg); |
||||
assert(io_s.ok()); |
||||
if (!io_s.ok()) { |
||||
return io_s; |
||||
} |
||||
result->reset( |
||||
new TestFSDirectory(this, TestFSTrimDirname(name), r.release())); |
||||
return IOStatus::OK(); |
||||
} |
||||
|
||||
IOStatus FaultInjectionTestFS::NewWritableFile( |
||||
const std::string& fname, const FileOptions& file_opts, |
||||
std::unique_ptr<FSWritableFile>* result, IODebugContext* dbg) { |
||||
if (!IsFilesystemActive()) { |
||||
return GetError(); |
||||
} |
||||
// Not allow overwriting files
|
||||
IOStatus io_s = target()->FileExists(fname, IOOptions(), dbg); |
||||
if (io_s.ok()) { |
||||
return IOStatus::Corruption("File already exists."); |
||||
} else if (!io_s.IsNotFound()) { |
||||
assert(io_s.IsIOError()); |
||||
return io_s; |
||||
} |
||||
io_s = target()->NewWritableFile(fname, file_opts, result, dbg); |
||||
if (io_s.ok()) { |
||||
result->reset(new TestFSWritableFile(fname, std::move(*result), this)); |
||||
// WritableFileWriter* file is opened
|
||||
// again then it will be truncated - so forget our saved state.
|
||||
UntrackFile(fname); |
||||
MutexLock l(&mutex_); |
||||
open_files_.insert(fname); |
||||
auto dir_and_name = TestFSGetDirAndName(fname); |
||||
auto& list = dir_to_new_files_since_last_sync_[dir_and_name.first]; |
||||
list.insert(dir_and_name.second); |
||||
} |
||||
return io_s; |
||||
} |
||||
|
||||
IOStatus FaultInjectionTestFS::ReopenWritableFile( |
||||
const std::string& fname, const FileOptions& file_opts, |
||||
std::unique_ptr<FSWritableFile>* result, IODebugContext* dbg) { |
||||
if (!IsFilesystemActive()) { |
||||
return GetError(); |
||||
} |
||||
IOStatus io_s = target()->ReopenWritableFile(fname, file_opts, result, dbg); |
||||
if (io_s.ok()) { |
||||
result->reset(new TestFSWritableFile(fname, std::move(*result), this)); |
||||
// WritableFileWriter* file is opened
|
||||
// again then it will be truncated - so forget our saved state.
|
||||
UntrackFile(fname); |
||||
MutexLock l(&mutex_); |
||||
open_files_.insert(fname); |
||||
auto dir_and_name = TestFSGetDirAndName(fname); |
||||
auto& list = dir_to_new_files_since_last_sync_[dir_and_name.first]; |
||||
list.insert(dir_and_name.second); |
||||
} |
||||
return io_s; |
||||
} |
||||
|
||||
IOStatus FaultInjectionTestFS::NewRandomRWFile( |
||||
const std::string& fname, const FileOptions& file_opts, |
||||
std::unique_ptr<FSRandomRWFile>* result, IODebugContext* dbg) { |
||||
if (!IsFilesystemActive()) { |
||||
return GetError(); |
||||
} |
||||
IOStatus io_s = target()->NewRandomRWFile(fname, file_opts, result, dbg); |
||||
if (io_s.ok()) { |
||||
result->reset(new TestFSRandomRWFile(fname, std::move(*result), this)); |
||||
// WritableFileWriter* file is opened
|
||||
// again then it will be truncated - so forget our saved state.
|
||||
UntrackFile(fname); |
||||
MutexLock l(&mutex_); |
||||
open_files_.insert(fname); |
||||
auto dir_and_name = TestFSGetDirAndName(fname); |
||||
auto& list = dir_to_new_files_since_last_sync_[dir_and_name.first]; |
||||
list.insert(dir_and_name.second); |
||||
} |
||||
return io_s; |
||||
} |
||||
|
||||
IOStatus FaultInjectionTestFS::NewRandomAccessFile( |
||||
const std::string& fname, const FileOptions& file_opts, |
||||
std::unique_ptr<FSRandomAccessFile>* result, IODebugContext* dbg) { |
||||
if (!IsFilesystemActive()) { |
||||
return GetError(); |
||||
} |
||||
return target()->NewRandomAccessFile(fname, file_opts, result, dbg); |
||||
} |
||||
|
||||
IOStatus FaultInjectionTestFS::DeleteFile(const std::string& f, |
||||
const IOOptions& options, |
||||
IODebugContext* dbg) { |
||||
if (!IsFilesystemActive()) { |
||||
return GetError(); |
||||
} |
||||
IOStatus io_s = FileSystemWrapper::DeleteFile(f, options, dbg); |
||||
if (!io_s.ok()) { |
||||
fprintf(stderr, "Cannot delete file %s: %s\n", f.c_str(), |
||||
io_s.ToString().c_str()); |
||||
} |
||||
if (io_s.ok()) { |
||||
UntrackFile(f); |
||||
} |
||||
return io_s; |
||||
} |
||||
|
||||
IOStatus FaultInjectionTestFS::RenameFile(const std::string& s, |
||||
const std::string& t, |
||||
const IOOptions& options, |
||||
IODebugContext* dbg) { |
||||
if (!IsFilesystemActive()) { |
||||
return GetError(); |
||||
} |
||||
IOStatus io_s = FileSystemWrapper::RenameFile(s, t, options, dbg); |
||||
|
||||
if (io_s.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); |
||||
} |
||||
|
||||
auto sdn = TestFSGetDirAndName(s); |
||||
auto tdn = TestFSGetDirAndName(t); |
||||
if (dir_to_new_files_since_last_sync_[sdn.first].erase(sdn.second) != 0) { |
||||
auto& tlist = dir_to_new_files_since_last_sync_[tdn.first]; |
||||
assert(tlist.find(tdn.second) == tlist.end()); |
||||
tlist.insert(tdn.second); |
||||
} |
||||
} |
||||
|
||||
return io_s; |
||||
} |
||||
|
||||
void FaultInjectionTestFS::WritableFileClosed(const FSFileState& state) { |
||||
MutexLock l(&mutex_); |
||||
if (open_files_.find(state.filename_) != open_files_.end()) { |
||||
db_file_state_[state.filename_] = state; |
||||
open_files_.erase(state.filename_); |
||||
} |
||||
} |
||||
|
||||
void FaultInjectionTestFS::WritableFileSynced(const FSFileState& state) { |
||||
MutexLock l(&mutex_); |
||||
if (open_files_.find(state.filename_) != open_files_.end()) { |
||||
if (db_file_state_.find(state.filename_) == db_file_state_.end()) { |
||||
db_file_state_.insert(std::make_pair(state.filename_, state)); |
||||
} else { |
||||
db_file_state_[state.filename_] = state; |
||||
} |
||||
} |
||||
} |
||||
|
||||
void FaultInjectionTestFS::WritableFileAppended(const FSFileState& state) { |
||||
MutexLock l(&mutex_); |
||||
if (open_files_.find(state.filename_) != open_files_.end()) { |
||||
if (db_file_state_.find(state.filename_) == db_file_state_.end()) { |
||||
db_file_state_.insert(std::make_pair(state.filename_, state)); |
||||
} else { |
||||
db_file_state_[state.filename_] = state; |
||||
} |
||||
} |
||||
} |
||||
|
||||
IOStatus FaultInjectionTestFS::DropUnsyncedFileData() { |
||||
IOStatus io_s; |
||||
MutexLock l(&mutex_); |
||||
for (std::map<std::string, FSFileState>::iterator it = db_file_state_.begin(); |
||||
io_s.ok() && it != db_file_state_.end(); ++it) { |
||||
FSFileState& fs_state = it->second; |
||||
if (!fs_state.IsFullySynced()) { |
||||
io_s = fs_state.DropUnsyncedData(); |
||||
} |
||||
} |
||||
return io_s; |
||||
} |
||||
|
||||
IOStatus FaultInjectionTestFS::DropRandomUnsyncedFileData(Random* rnd) { |
||||
IOStatus io_s; |
||||
MutexLock l(&mutex_); |
||||
for (std::map<std::string, FSFileState>::iterator it = db_file_state_.begin(); |
||||
io_s.ok() && it != db_file_state_.end(); ++it) { |
||||
FSFileState& fs_state = it->second; |
||||
if (!fs_state.IsFullySynced()) { |
||||
io_s = fs_state.DropRandomUnsyncedData(rnd); |
||||
} |
||||
} |
||||
return io_s; |
||||
} |
||||
|
||||
IOStatus FaultInjectionTestFS::DeleteFilesCreatedAfterLastDirSync( |
||||
const IOOptions& options, IODebugContext* dbg) { |
||||
// Because DeleteFile access this container make a copy to avoid deadlock
|
||||
std::map<std::string, std::set<std::string>> map_copy; |
||||
{ |
||||
MutexLock l(&mutex_); |
||||
map_copy.insert(dir_to_new_files_since_last_sync_.begin(), |
||||
dir_to_new_files_since_last_sync_.end()); |
||||
} |
||||
|
||||
for (auto& pair : map_copy) { |
||||
for (std::string name : pair.second) { |
||||
IOStatus io_s = DeleteFile(pair.first + "/" + name, options, dbg); |
||||
if (!io_s.ok()) { |
||||
return io_s; |
||||
} |
||||
} |
||||
} |
||||
return IOStatus::OK(); |
||||
} |
||||
|
||||
void FaultInjectionTestFS::ResetState() { |
||||
MutexLock l(&mutex_); |
||||
db_file_state_.clear(); |
||||
dir_to_new_files_since_last_sync_.clear(); |
||||
SetFilesystemActiveNoLock(true); |
||||
} |
||||
|
||||
void FaultInjectionTestFS::UntrackFile(const std::string& f) { |
||||
MutexLock l(&mutex_); |
||||
auto dir_and_name = TestFSGetDirAndName(f); |
||||
dir_to_new_files_since_last_sync_[dir_and_name.first].erase( |
||||
dir_and_name.second); |
||||
db_file_state_.erase(f); |
||||
open_files_.erase(f); |
||||
} |
||||
|
||||
} // namespace ROCKSDB_NAMESPACE
|
||||
@ -0,0 +1,251 @@ |
||||
// Copyright (c) 2011-present, Facebook, Inc. All rights reserved.
|
||||
// This source code is licensed under both the GPLv2 (found in the
|
||||
// COPYING file in the root directory) and Apache 2.0 License
|
||||
// (found in the LICENSE.Apache file in the root directory).
|
||||
//
|
||||
// Copyright 2014 The LevelDB Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style license that can be
|
||||
// found in the LICENSE file. See the AUTHORS file for names of contributors.
|
||||
|
||||
// This test uses a custom FileSystem to keep track of the state of a file
|
||||
// system the last "Sync". The data being written is cached in a "buffer".
|
||||
// Only when "Sync" is called, the data will be persistent. It can similate
|
||||
// file data loss (or entire files) not protected by a "Sync". For any of the
|
||||
// FileSystem related operations, by specify the "IOStatus Error", a specific
|
||||
// error can be returned when file system is not activated.
|
||||
|
||||
#pragma once |
||||
|
||||
#include <map> |
||||
#include <set> |
||||
#include <string> |
||||
|
||||
#include "db/version_set.h" |
||||
#include "env/mock_env.h" |
||||
#include "file/filename.h" |
||||
#include "include/rocksdb/file_system.h" |
||||
#include "rocksdb/db.h" |
||||
#include "rocksdb/env.h" |
||||
#include "util/mutexlock.h" |
||||
#include "util/random.h" |
||||
|
||||
namespace ROCKSDB_NAMESPACE { |
||||
|
||||
class TestFSWritableFile; |
||||
class FaultInjectionTestFS; |
||||
|
||||
struct FSFileState { |
||||
std::string filename_; |
||||
ssize_t pos_; |
||||
ssize_t pos_at_last_sync_; |
||||
ssize_t pos_at_last_flush_; |
||||
std::string buffer_; |
||||
|
||||
explicit FSFileState(const std::string& filename) |
||||
: filename_(filename), |
||||
pos_(-1), |
||||
pos_at_last_sync_(-1), |
||||
pos_at_last_flush_(-1) {} |
||||
|
||||
FSFileState() : pos_(-1), pos_at_last_sync_(-1), pos_at_last_flush_(-1) {} |
||||
|
||||
bool IsFullySynced() const { return pos_ <= 0 || pos_ == pos_at_last_sync_; } |
||||
|
||||
IOStatus DropUnsyncedData(); |
||||
|
||||
IOStatus DropRandomUnsyncedData(Random* rand); |
||||
}; |
||||
|
||||
// A wrapper around WritableFileWriter* file
|
||||
// is written to or sync'ed.
|
||||
class TestFSWritableFile : public FSWritableFile { |
||||
public: |
||||
explicit TestFSWritableFile(const std::string& fname, |
||||
std::unique_ptr<FSWritableFile>&& f, |
||||
FaultInjectionTestFS* fs); |
||||
virtual ~TestFSWritableFile(); |
||||
virtual IOStatus Append(const Slice& data, const IOOptions&, |
||||
IODebugContext*) override; |
||||
virtual IOStatus Truncate(uint64_t size, const IOOptions& options, |
||||
IODebugContext* dbg) override { |
||||
return target_->Truncate(size, options, dbg); |
||||
} |
||||
virtual IOStatus Close(const IOOptions& options, |
||||
IODebugContext* dbg) override; |
||||
virtual IOStatus Flush(const IOOptions&, IODebugContext*) override; |
||||
virtual IOStatus Sync(const IOOptions& options, IODebugContext* dbg) override; |
||||
virtual bool IsSyncThreadSafe() const override { return true; } |
||||
virtual IOStatus PositionedAppend(const Slice& data, uint64_t offset, |
||||
const IOOptions& options, |
||||
IODebugContext* dbg) override { |
||||
return target_->PositionedAppend(data, offset, options, dbg); |
||||
} |
||||
virtual bool use_direct_io() const override { |
||||
return target_->use_direct_io(); |
||||
}; |
||||
|
||||
private: |
||||
FSFileState state_; |
||||
std::unique_ptr<FSWritableFile> target_; |
||||
bool writable_file_opened_; |
||||
FaultInjectionTestFS* fs_; |
||||
port::Mutex mutex_; |
||||
}; |
||||
|
||||
// A wrapper around WritableFileWriter* file
|
||||
// is written to or sync'ed.
|
||||
class TestFSRandomRWFile : public FSRandomRWFile { |
||||
public: |
||||
explicit TestFSRandomRWFile(const std::string& fname, |
||||
std::unique_ptr<FSRandomRWFile>&& f, |
||||
FaultInjectionTestFS* fs); |
||||
virtual ~TestFSRandomRWFile(); |
||||
IOStatus Write(uint64_t offset, const Slice& data, const IOOptions& options, |
||||
IODebugContext* dbg) override; |
||||
IOStatus Read(uint64_t offset, size_t n, const IOOptions& options, |
||||
Slice* result, char* scratch, |
||||
IODebugContext* dbg) const override; |
||||
IOStatus Close(const IOOptions& options, IODebugContext* dbg) override; |
||||
IOStatus Flush(const IOOptions& options, IODebugContext* dbg) override; |
||||
IOStatus Sync(const IOOptions& options, IODebugContext* dbg) override; |
||||
size_t GetRequiredBufferAlignment() const override { |
||||
return target_->GetRequiredBufferAlignment(); |
||||
} |
||||
bool use_direct_io() const override { return target_->use_direct_io(); }; |
||||
|
||||
private: |
||||
std::unique_ptr<FSRandomRWFile> target_; |
||||
bool file_opened_; |
||||
FaultInjectionTestFS* fs_; |
||||
}; |
||||
|
||||
class TestFSDirectory : public FSDirectory { |
||||
public: |
||||
explicit TestFSDirectory(FaultInjectionTestFS* fs, std::string dirname, |
||||
FSDirectory* dir) |
||||
: fs_(fs), dirname_(dirname), dir_(dir) {} |
||||
~TestFSDirectory() {} |
||||
|
||||
virtual IOStatus Fsync(const IOOptions& options, |
||||
IODebugContext* dbg) override; |
||||
|
||||
private: |
||||
FaultInjectionTestFS* fs_; |
||||
std::string dirname_; |
||||
std::unique_ptr<FSDirectory> dir_; |
||||
}; |
||||
|
||||
class FaultInjectionTestFS : public FileSystemWrapper { |
||||
public: |
||||
explicit FaultInjectionTestFS(FileSystem* base) |
||||
: FileSystemWrapper(base), filesystem_active_(true) {} |
||||
virtual ~FaultInjectionTestFS() {} |
||||
|
||||
const char* Name() const override { return "FaultInjectionTestFS"; } |
||||
|
||||
IOStatus NewDirectory(const std::string& name, const IOOptions& options, |
||||
std::unique_ptr<FSDirectory>* result, |
||||
IODebugContext* dbg) override; |
||||
|
||||
IOStatus NewWritableFile(const std::string& fname, |
||||
const FileOptions& file_opts, |
||||
std::unique_ptr<FSWritableFile>* result, |
||||
IODebugContext* dbg) override; |
||||
|
||||
IOStatus ReopenWritableFile(const std::string& fname, |
||||
const FileOptions& file_opts, |
||||
std::unique_ptr<FSWritableFile>* result, |
||||
IODebugContext* dbg) override; |
||||
|
||||
IOStatus NewRandomRWFile(const std::string& fname, |
||||
const FileOptions& file_opts, |
||||
std::unique_ptr<FSRandomRWFile>* result, |
||||
IODebugContext* dbg) override; |
||||
|
||||
IOStatus NewRandomAccessFile(const std::string& fname, |
||||
const FileOptions& file_opts, |
||||
std::unique_ptr<FSRandomAccessFile>* result, |
||||
IODebugContext* dbg) override; |
||||
|
||||
virtual IOStatus DeleteFile(const std::string& f, const IOOptions& options, |
||||
IODebugContext* dbg) override; |
||||
|
||||
virtual IOStatus RenameFile(const std::string& s, const std::string& t, |
||||
const IOOptions& options, |
||||
IODebugContext* dbg) override; |
||||
|
||||
// Undef to eliminate clash on Windows
|
||||
#undef GetFreeSpace |
||||
virtual IOStatus GetFreeSpace(const std::string& path, |
||||
const IOOptions& options, uint64_t* disk_free, |
||||
IODebugContext* dbg) override { |
||||
if (!IsFilesystemActive() && error_ == IOStatus::NoSpace()) { |
||||
*disk_free = 0; |
||||
return IOStatus::OK(); |
||||
} else { |
||||
return target()->GetFreeSpace(path, options, disk_free, dbg); |
||||
} |
||||
} |
||||
|
||||
void WritableFileClosed(const FSFileState& state); |
||||
|
||||
void WritableFileSynced(const FSFileState& state); |
||||
|
||||
void WritableFileAppended(const FSFileState& state); |
||||
|
||||
IOStatus DropUnsyncedFileData(); |
||||
|
||||
IOStatus DropRandomUnsyncedFileData(Random* rnd); |
||||
|
||||
IOStatus DeleteFilesCreatedAfterLastDirSync(const IOOptions& options, |
||||
IODebugContext* dbg); |
||||
|
||||
void ResetState(); |
||||
|
||||
void UntrackFile(const std::string& f); |
||||
|
||||
void SyncDir(const std::string& dirname) { |
||||
MutexLock l(&mutex_); |
||||
dir_to_new_files_since_last_sync_.erase(dirname); |
||||
} |
||||
|
||||
// Setting the filesystem to inactive is the test equivalent to simulating a
|
||||
// system reset. Setting to inactive will freeze our saved filesystem state so
|
||||
// that it will stop being recorded. It can then be reset back to the state at
|
||||
// the time of the reset.
|
||||
bool IsFilesystemActive() { |
||||
MutexLock l(&mutex_); |
||||
return filesystem_active_; |
||||
} |
||||
void SetFilesystemActiveNoLock( |
||||
bool active, IOStatus error = IOStatus::Corruption("Not active")) { |
||||
filesystem_active_ = active; |
||||
if (!active) { |
||||
error_ = error; |
||||
} |
||||
} |
||||
void SetFilesystemActive( |
||||
bool active, IOStatus error = IOStatus::Corruption("Not active")) { |
||||
MutexLock l(&mutex_); |
||||
SetFilesystemActiveNoLock(active, error); |
||||
} |
||||
void AssertNoOpenFile() { assert(open_files_.empty()); } |
||||
|
||||
IOStatus GetError() { return error_; } |
||||
|
||||
void SetFileSystemIOError(IOStatus io_error) { |
||||
MutexLock l(&mutex_); |
||||
error_ = io_error; |
||||
} |
||||
|
||||
private: |
||||
port::Mutex mutex_; |
||||
std::map<std::string, FSFileState> db_file_state_; |
||||
std::set<std::string> open_files_; |
||||
std::unordered_map<std::string, std::set<std::string>> |
||||
dir_to_new_files_since_last_sync_; |
||||
bool filesystem_active_; // Record flushes, syncs, writes
|
||||
IOStatus error_; |
||||
}; |
||||
|
||||
} // namespace ROCKSDB_NAMESPACE
|
||||
Loading…
Reference in new issue