Inside Bitcoin

1// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file. See the AUTHORS file for names of contributors.
4
5#include "leveldb/db.h"
6
7#include <atomic>
8#include <string>
9
10#include "db/db_impl.h"
11#include "db/filename.h"
12#include "db/version_set.h"
13#include "db/write_batch_internal.h"
14#include "leveldb/cache.h"
15#include "leveldb/env.h"
16#include "leveldb/filter_policy.h"
17#include "leveldb/table.h"
18#include "port/port.h"
19#include "port/thread_annotations.h"
20#include "util/hash.h"
21#include "util/logging.h"
22#include "util/mutexlock.h"
23#include "util/testharness.h"
24#include "util/testutil.h"
25
26namespace leveldb {
27
28static std::string RandomString(Random* rnd, int len) {
29  std::string r;
30  test::RandomString(rnd, len, &r);
31  return r;
32}
33
34static std::string RandomKey(Random* rnd) {
35  int len =
36      (rnd->OneIn(3) ? 1  // Short sometimes to encourage collisions
37                     : (rnd->OneIn(100) ? rnd->Skewed(10) : rnd->Uniform(10)));
38  return test::RandomKey(rnd, len);
39}
40
41namespace {
42class AtomicCounter {
43 public:
44  AtomicCounter() : count_(0) {}
45  void Increment() { IncrementBy(1); }
46  void IncrementBy(int count) LOCKS_EXCLUDED(mu_) {
47    MutexLock l(&mu_);
48    count_ += count;
49  }
50  int Read() LOCKS_EXCLUDED(mu_) {
51    MutexLock l(&mu_);
52    return count_;
53  }
54  void Reset() LOCKS_EXCLUDED(mu_) {
55    MutexLock l(&mu_);
56    count_ = 0;
57  }
58
59 private:
60  port::Mutex mu_;
61  int count_ GUARDED_BY(mu_);
62};
63
64void DelayMilliseconds(int millis) {
65  Env::Default()->SleepForMicroseconds(millis * 1000);
66}
67}  // namespace
68
69// Test Env to override default Env behavior for testing.
70class TestEnv : public EnvWrapper {
71 public:
72  explicit TestEnv(Env* base) : EnvWrapper(base), ignore_dot_files_(false) {}
73
74  void SetIgnoreDotFiles(bool ignored) { ignore_dot_files_ = ignored; }
75
76  Status GetChildren(const std::string& dir,
77                     std::vector<std::string>* result) override {
78    Status s = target()->GetChildren(dir, result);
79    if (!s.ok() || !ignore_dot_files_) {
80      return s;
81    }
82
83    std::vector<std::string>::iterator it = result->begin();
84    while (it != result->end()) {
85      if ((*it == ".") || (*it == "..")) {
86        it = result->erase(it);
87      } else {
88        ++it;
89      }
90    }
91
92    return s;
93  }
94
95 private:
96  bool ignore_dot_files_;
97};
98
99// Special Env used to delay background operations.
100class SpecialEnv : public EnvWrapper {
101 public:
102  // sstable/log Sync() calls are blocked while this pointer is non-null.
103  std::atomic<bool> delay_data_sync_;
104
105  // sstable/log Sync() calls return an error.
106  std::atomic<bool> data_sync_error_;
107
108  // Simulate no-space errors while this pointer is non-null.
109  std::atomic<bool> no_space_;
110
111  // Simulate non-writable file system while this pointer is non-null.
112  std::atomic<bool> non_writable_;
113
114  // Force sync of manifest files to fail while this pointer is non-null.
115  std::atomic<bool> manifest_sync_error_;
116
117  // Force write to manifest files to fail while this pointer is non-null.
118  std::atomic<bool> manifest_write_error_;
119
120  bool count_random_reads_;
121  AtomicCounter random_read_counter_;
122
123  explicit SpecialEnv(Env* base)
124      : EnvWrapper(base),
125        delay_data_sync_(false),
126        data_sync_error_(false),
127        no_space_(false),
128        non_writable_(false),
129        manifest_sync_error_(false),
130        manifest_write_error_(false),
131        count_random_reads_(false) {}
132
133  Status NewWritableFile(const std::string& f, WritableFile** r) {
134    class DataFile : public WritableFile {
135     private:
136      SpecialEnv* const env_;
137      WritableFile* const base_;
138
139     public:
140      DataFile(SpecialEnv* env, WritableFile* base) : env_(env), base_(base) {}
141      ~DataFile() { delete base_; }
142      Status Append(const Slice& data) override {
143        if (env_->no_space_.load(std::memory_order_acquire)) {
144          // Drop writes on the floor
145          return Status::OK();
146        } else {
147          return base_->Append(data);
148        }
149      }
150      Status Close() override { return base_->Close(); }
151      Status Flush() override { return base_->Flush(); }
152      Status Sync() override {
153        if (env_->data_sync_error_.load(std::memory_order_acquire)) {
154          return Status::IOError("simulated data sync error");
155        }
156        while (env_->delay_data_sync_.load(std::memory_order_acquire)) {
157          DelayMilliseconds(100);
158        }
159        return base_->Sync();
160      }
161      std::string GetName() const override { return ""; }
162    };
163    class ManifestFile : public WritableFile {
164     private:
165      SpecialEnv* env_;
166      WritableFile* base_;
167
168     public:
169      ManifestFile(SpecialEnv* env, WritableFile* b) : env_(env), base_(b) {}
170      ~ManifestFile() { delete base_; }
171      Status Append(const Slice& data) override {
172        if (env_->manifest_write_error_.load(std::memory_order_acquire)) {
173          return Status::IOError("simulated writer error");
174        } else {
175          return base_->Append(data);
176        }
177      }
178      Status Close() override { return base_->Close(); }
179      Status Flush() override { return base_->Flush(); }
180      Status Sync() override {
181        if (env_->manifest_sync_error_.load(std::memory_order_acquire)) {
182          return Status::IOError("simulated sync error");
183        } else {
184          return base_->Sync();
185        }
186      }
187      std::string GetName() const override { return ""; }
188    };
189
190    if (non_writable_.load(std::memory_order_acquire)) {
191      return Status::IOError("simulated write error");
192    }
193
194    Status s = target()->NewWritableFile(f, r);
195    if (s.ok()) {
196      if (strstr(f.c_str(), ".ldb") != nullptr ||
197          strstr(f.c_str(), ".log") != nullptr) {
198        *r = new DataFile(this, *r);
199      } else if (strstr(f.c_str(), "MANIFEST") != nullptr) {
200        *r = new ManifestFile(this, *r);
201      }
202    }
203    return s;
204  }
205
206  Status NewRandomAccessFile(const std::string& f, RandomAccessFile** r) {
207    class CountingFile : public RandomAccessFile {
208     private:
209      RandomAccessFile* target_;
210      AtomicCounter* counter_;
211
212     public:
213      CountingFile(RandomAccessFile* target, AtomicCounter* counter)
214          : target_(target), counter_(counter) {}
215      ~CountingFile() override { delete target_; }
216      Status Read(uint64_t offset, size_t n, Slice* result,
217                  char* scratch) const override {
218        counter_->Increment();
219        return target_->Read(offset, n, result, scratch);
220      }
221      std::string GetName() const override { return ""; }
222    };
223
224    Status s = target()->NewRandomAccessFile(f, r);
225    if (s.ok() && count_random_reads_) {
226      *r = new CountingFile(*r, &random_read_counter_);
227    }
228    return s;
229  }
230};
231
232class DBTest {
233 public:
234  std::string dbname_;
235  SpecialEnv* env_;
236  DB* db_;
237
238  Options last_options_;
239
240  DBTest() : env_(new SpecialEnv(Env::Default())), option_config_(kDefault) {
241    filter_policy_ = NewBloomFilterPolicy(10);
242    dbname_ = test::TmpDir() + "/db_test";
243    DestroyDB(dbname_, Options());
244    db_ = nullptr;
245    Reopen();
246  }
247
248  ~DBTest() {
249    delete db_;
250    DestroyDB(dbname_, Options());