1  // Copyright (c) 2012 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/dumpfile.h"
  6  
  7  #include <stdio.h>
  8  
  9  #include "db/dbformat.h"
 10  #include "db/filename.h"
 11  #include "db/log_reader.h"
 12  #include "db/version_edit.h"
 13  #include "db/write_batch_internal.h"
 14  #include "leveldb/env.h"
 15  #include "leveldb/iterator.h"
 16  #include "leveldb/options.h"
 17  #include "leveldb/status.h"
 18  #include "leveldb/table.h"
 19  #include "leveldb/write_batch.h"
 20  #include "util/logging.h"
 21  
 22  namespace leveldb {
 23  
 24  namespace {
 25  
 26  bool GuessType(const std::string& fname, FileType* type) {
 27    size_t pos = fname.rfind('/');
 28    std::string basename;
 29    if (pos == std::string::npos) {
 30      basename = fname;
 31    } else {
 32      basename = std::string(fname.data() + pos + 1, fname.size() - pos - 1);
 33    }
 34    uint64_t ignored;
 35    return ParseFileName(basename, &ignored, type);
 36  }
 37  
 38  // Notified when log reader encounters corruption.
 39  class CorruptionReporter : public log::Reader::Reporter {
 40   public:
 41    void Corruption(size_t bytes, const Status& status) override {
 42      std::string r = "corruption: ";
 43      AppendNumberTo(&r, bytes);
 44      r += " bytes; ";
 45      r += status.ToString();
 46      r.push_back('\n');
 47      dst_->Append(r);
 48    }
 49  
 50    WritableFile* dst_;
 51  };
 52  
 53  // Print contents of a log file. (*func)() is called on every record.
 54  Status PrintLogContents(Env* env, const std::string& fname,
 55                          void (*func)(uint64_t, Slice, WritableFile*),
 56                          WritableFile* dst) {
 57    SequentialFile* file;
 58    Status s = env->NewSequentialFile(fname, &file);
 59    if (!s.ok()) {
 60      return s;
 61    }
 62    CorruptionReporter reporter;
 63    reporter.dst_ = dst;
 64    log::Reader reader(file, &reporter, true, 0);
 65    Slice record;
 66    std::string scratch;
 67    while (reader.ReadRecord(&record, &scratch)) {
 68      (*func)(reader.LastRecordOffset(), record, dst);
 69    }
 70    delete file;
 71    return Status::OK();
 72  }
 73  
 74  // Called on every item found in a WriteBatch.
 75  class WriteBatchItemPrinter : public WriteBatch::Handler {
 76   public:
 77    void Put(const Slice& key, const Slice& value) override {
 78      std::string r = "  put '";
 79      AppendEscapedStringTo(&r, key);
 80      r += "' '";
 81      AppendEscapedStringTo(&r, value);
 82      r += "'\n";
 83      dst_->Append(r);
 84    }
 85    void Delete(const Slice& key) override {
 86      std::string r = "  del '";
 87      AppendEscapedStringTo(&r, key);
 88      r += "'\n";
 89      dst_->Append(r);
 90    }
 91  
 92    WritableFile* dst_;
 93  };
 94  
 95  // Called on every log record (each one of which is a WriteBatch)
 96  // found in a kLogFile.
 97  static void WriteBatchPrinter(uint64_t pos, Slice record, WritableFile* dst) {
 98    std::string r = "--- offset ";
 99    AppendNumberTo(&r, pos);
100    r += "; ";
101    if (record.size() < 12) {
102      r += "log record length ";
103      AppendNumberTo(&r, record.size());
104      r += " is too small\n";
105      dst->Append(r);
106      return;
107    }
108    WriteBatch batch;
109    WriteBatchInternal::SetContents(&batch, record);
110    r += "sequence ";
111    AppendNumberTo(&r, WriteBatchInternal::Sequence(&batch));
112    r.push_back('\n');
113    dst->Append(r);
114    WriteBatchItemPrinter batch_item_printer;
115    batch_item_printer.dst_ = dst;
116    Status s = batch.Iterate(&batch_item_printer);
117    if (!s.ok()) {
118      dst->Append("  error: " + s.ToString() + "\n");
119    }
120  }
121  
122  Status DumpLog(Env* env, const std::string& fname, WritableFile* dst) {
123    return PrintLogContents(env, fname, WriteBatchPrinter, dst);
124  }
125  
126  // Called on every log record (each one of which is a WriteBatch)
127  // found in a kDescriptorFile.
128  static void VersionEditPrinter(uint64_t pos, Slice record, WritableFile* dst) {
129    std::string r = "--- offset ";
130    AppendNumberTo(&r, pos);
131    r += "; ";
132    VersionEdit edit;
133    Status s = edit.DecodeFrom(record);
134    if (!s.ok()) {
135      r += s.ToString();
136      r.push_back('\n');
137    } else {
138      r += edit.DebugString();
139    }
140    dst->Append(r);
141  }
142  
143  Status DumpDescriptor(Env* env, const std::string& fname, WritableFile* dst) {
144    return PrintLogContents(env, fname, VersionEditPrinter, dst);
145  }
146  
147  Status DumpTable(Env* env, const std::string& fname, WritableFile* dst) {
148    uint64_t file_size;
149    RandomAccessFile* file = nullptr;
150    Table* table = nullptr;
151    Status s = env->GetFileSize(fname, &file_size);
152    if (s.ok()) {
153      s = env->NewRandomAccessFile(fname, &file);
154    }
155    if (s.ok()) {
156      // We use the default comparator, which may or may not match the
157      // comparator used in this database. However this should not cause
158      // problems since we only use Table operations that do not require
159      // any comparisons.  In particular, we do not call Seek or Prev.
160      s = Table::Open(Options(), file, file_size, &table);
161    }
162    if (!s.ok()) {
163      delete table;
164      delete file;
165      return s;
166    }
167  
168    ReadOptions ro;
169    ro.fill_cache = false;
170    Iterator* iter = table->NewIterator(ro);
171    std::string r;
172    for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
173      r.clear();
174      ParsedInternalKey key;
175      if (!ParseInternalKey(iter->key(), &key)) {
176        r = "badkey '";
177        AppendEscapedStringTo(&r, iter->key());
178        r += "' => '";
179        AppendEscapedStringTo(&r, iter->value());
180        r += "'\n";
181        dst->Append(r);
182      } else {
183        r = "'";
184        AppendEscapedStringTo(&r, key.user_key);
185        r += "' @ ";
186        AppendNumberTo(&r, key.sequence);
187        r += " : ";
188        if (key.type == kTypeDeletion) {
189          r += "del";
190        } else if (key.type == kTypeValue) {
191          r += "val";
192        } else {
193          AppendNumberTo(&r, key.type);
194        }
195        r += " => '";
196        AppendEscapedStringTo(&r, iter->value());
197        r += "'\n";
198        dst->Append(r);
199      }
200    }
201    s = iter->status();
202    if (!s.ok()) {
203      dst->Append("iterator error: " + s.ToString() + "\n");
204    }
205  
206    delete iter;
207    delete table;
208    delete file;
209    return Status::OK();
210  }
211  
212  }  // namespace
213  
214  Status DumpFile(Env* env, const std::string& fname, WritableFile* dst) {
215    FileType ftype;
216    if (!GuessType(fname, &ftype)) {
217      return Status::InvalidArgument(fname + ": unknown file type");
218    }
219    switch (ftype) {
220      case kLogFile:
221        return DumpLog(env, fname, dst);
222      case kDescriptorFile:
223        return DumpDescriptor(env, fname, dst);
224      case kTableFile:
225        return DumpTable(env, fname, dst);
226      default:
227        break;
228    }
229    return Status::InvalidArgument(fname + ": not a dump-able file type");
230  }
231  
232  }  // namespace leveldb