leveldb::SpecialEnv Class Reference

Inheritance diagram for leveldb::SpecialEnv:

Collaboration diagram for leveldb::SpecialEnv:

Public Member Functions
	SpecialEnv (Env *base)
Status	NewWritableFile (const std::string &f, WritableFile **r)
Status	NewRandomAccessFile (const std::string &f, RandomAccessFile **r)
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

Public Attributes
port::AtomicPointer	delay_data_sync_
port::AtomicPointer	data_sync_error_
port::AtomicPointer	no_space_
port::AtomicPointer	non_writable_
port::AtomicPointer	manifest_sync_error_
port::AtomicPointer	manifest_write_error_
bool	count_random_reads_
AtomicCounter	random_read_counter_

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

Detailed Description

Definition at line 58 of file db_test.cc.

Constructor & Destructor Documentation

SpecialEnv()

leveldb::SpecialEnv::SpecialEnv ( Env *  base )

inlineexplicit

Definition at line 81 of file db_test.cc.

                                 : EnvWrapper(base) {
    delay_data_sync_.Release_Store(NULL);
    data_sync_error_.Release_Store(NULL);
    no_space_.Release_Store(NULL);
    non_writable_.Release_Store(NULL);
    count_random_reads_ = false;
    manifest_sync_error_.Release_Store(NULL);
    manifest_write_error_.Release_Store(NULL);
  }

Member Function Documentation

NewRandomAccessFile()

Status leveldb::SpecialEnv::NewRandomAccessFile ( const std::string &  f, RandomAccessFile **  r  )

inlinevirtual

Implements leveldb::Env.

Definition at line 164 of file db_test.cc.

                                                                       {
    class CountingFile : public RandomAccessFile {
     private:
      RandomAccessFile* target_;
      AtomicCounter* counter_;
     public:
      CountingFile(RandomAccessFile* target, AtomicCounter* counter)
          : target_(target), counter_(counter) {
      }
      virtual ~CountingFile() { delete target_; }
      virtual Status Read(uint64_t offset, size_t n, Slice* result,
                          char* scratch) const {
        counter_->Increment();
        return target_->Read(offset, n, result, scratch);
      }
    };

    Status s = target()->NewRandomAccessFile(f, r);
    if (s.ok() && count_random_reads_) {
      *r = new CountingFile(*r, &random_read_counter_);
    }
    return s;
  }

Here is the call graph for this function:

NewWritableFile()

Status leveldb::SpecialEnv::NewWritableFile ( const std::string &  f, WritableFile **  r  )

inlinevirtual

Implements leveldb::Env.

Definition at line 91 of file db_test.cc.

                                                               {
    class DataFile : public WritableFile {
     private:
      SpecialEnv* env_;
      WritableFile* base_;

     public:
      DataFile(SpecialEnv* env, WritableFile* base)
          : env_(env),
            base_(base) {
      }
      ~DataFile() { delete base_; }
      Status Append(const Slice& data) {
        if (env_->no_space_.Acquire_Load() != NULL) {
          // Drop writes on the floor
          return Status::OK();
        } else {
          return base_->Append(data);
        }
      }
      Status Close() { return base_->Close(); }
      Status Flush() { return base_->Flush(); }
      Status Sync() {
        if (env_->data_sync_error_.Acquire_Load() != NULL) {
          return Status::IOError("simulated data sync error");
        }
        while (env_->delay_data_sync_.Acquire_Load() != NULL) {
          DelayMilliseconds(100);
        }
        return base_->Sync();
      }
    };
    class ManifestFile : public WritableFile {
     private:
      SpecialEnv* env_;
      WritableFile* base_;
     public:
      ManifestFile(SpecialEnv* env, WritableFile* b) : env_(env), base_(b) { }
      ~ManifestFile() { delete base_; }
      Status Append(const Slice& data) {
        if (env_->manifest_write_error_.Acquire_Load() != NULL) {
          return Status::IOError("simulated writer error");
        } else {
          return base_->Append(data);
        }
      }
      Status Close() { return base_->Close(); }
      Status Flush() { return base_->Flush(); }
      Status Sync() {
        if (env_->manifest_sync_error_.Acquire_Load() != NULL) {
          return Status::IOError("simulated sync error");
        } else {
          return base_->Sync();
        }
      }
    };

    if (non_writable_.Acquire_Load() != NULL) {
      return Status::IOError("simulated write error");
    }

    Status s = target()->NewWritableFile(f, r);
    if (s.ok()) {
      if (strstr(f.c_str(), ".ldb") != NULL ||
          strstr(f.c_str(), ".log") != NULL) {
        *r = new DataFile(this, *r);
      } else if (strstr(f.c_str(), "MANIFEST") != NULL) {
        *r = new ManifestFile(this, *r);
      }
    }
    return s;
  }

Here is the call graph for this function:

Member Data Documentation

count_random_reads_

bool leveldb::SpecialEnv::count_random_reads_

Definition at line 78 of file db_test.cc.

data_sync_error_

port::AtomicPointer leveldb::SpecialEnv::data_sync_error_

Definition at line 64 of file db_test.cc.

delay_data_sync_

port::AtomicPointer leveldb::SpecialEnv::delay_data_sync_

Definition at line 61 of file db_test.cc.

manifest_sync_error_

port::AtomicPointer leveldb::SpecialEnv::manifest_sync_error_

Definition at line 73 of file db_test.cc.

manifest_write_error_

port::AtomicPointer leveldb::SpecialEnv::manifest_write_error_

Definition at line 76 of file db_test.cc.

no_space_

port::AtomicPointer leveldb::SpecialEnv::no_space_

Definition at line 67 of file db_test.cc.

non_writable_

port::AtomicPointer leveldb::SpecialEnv::non_writable_

Definition at line 70 of file db_test.cc.

random_read_counter_

AtomicCounter leveldb::SpecialEnv::random_read_counter_

Definition at line 79 of file db_test.cc.

---

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

• db/db_test.cc