OLD | NEW |
(Empty) | |
| 1 // Copyright 2015 The Chromium 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. |
| 4 |
| 5 #include "chrome/browser/android/history_report/delta_file_backend_leveldb.h" |
| 6 |
| 7 #include <inttypes.h> |
| 8 #include "base/files/file_util.h" |
| 9 #include "base/logging.h" |
| 10 #include "base/strings/string_number_conversions.h" |
| 11 #include "base/strings/stringprintf.h" |
| 12 #include "chrome/browser/android/history_report/delta_file_commons.h" |
| 13 #include "third_party/leveldatabase/src/include/leveldb/comparator.h" |
| 14 #include "third_party/leveldatabase/src/include/leveldb/db.h" |
| 15 #include "third_party/leveldatabase/src/include/leveldb/iterator.h" |
| 16 #include "third_party/leveldatabase/src/include/leveldb/options.h" |
| 17 #include "third_party/leveldatabase/src/include/leveldb/slice.h" |
| 18 #include "third_party/leveldatabase/src/include/leveldb/status.h" |
| 19 #include "third_party/leveldatabase/src/include/leveldb/write_batch.h" |
| 20 #include "url/gurl.h" |
| 21 |
| 22 namespace { |
| 23 const base::FilePath::CharType kDbFileName[] = |
| 24 FILE_PATH_LITERAL("DeltaFileLevelDb"); |
| 25 |
| 26 int64 GetLastSeqNo(leveldb::DB* db) { |
| 27 leveldb::ReadOptions options; |
| 28 scoped_ptr<leveldb::Iterator> db_iter(db->NewIterator(options)); |
| 29 db_iter->SeekToLast(); |
| 30 int64 seq_no = 0; |
| 31 if (db_iter->Valid()) { |
| 32 history_report::DeltaFileEntry last_entry; |
| 33 leveldb::Slice value_slice = db_iter->value(); |
| 34 if (last_entry.ParseFromArray(value_slice.data(), value_slice.size())) |
| 35 seq_no = last_entry.seq_no(); |
| 36 } |
| 37 return seq_no; |
| 38 } |
| 39 |
| 40 void SaveChange(leveldb::DB* db, std::string url, std::string type) { |
| 41 int64 seq_no = GetLastSeqNo(db) + 1; |
| 42 history_report::DeltaFileEntry entry; |
| 43 entry.set_seq_no(seq_no); |
| 44 entry.set_type(type); |
| 45 entry.set_url(url); |
| 46 leveldb::WriteOptions writeOptions; |
| 47 std::string key; |
| 48 base::SStringPrintf(&key, "%" PRId64, seq_no); |
| 49 leveldb::Status status = db->Put( |
| 50 writeOptions, |
| 51 leveldb::Slice(key), |
| 52 leveldb::Slice(entry.SerializeAsString())); |
| 53 if (!status.ok()) |
| 54 LOG(WARNING) << "Save Change failed " << status.ToString(); |
| 55 } |
| 56 |
| 57 } // namespace |
| 58 |
| 59 namespace history_report { |
| 60 |
| 61 // Comparator used in leveldb. |
| 62 class DeltaFileBackend::DigitsComparator : public leveldb::Comparator { |
| 63 public: |
| 64 int Compare(const leveldb::Slice& a, |
| 65 const leveldb::Slice& b) const override { |
| 66 int64 first; |
| 67 int64 second; |
| 68 // Keys which can't be parsed go to the end. |
| 69 if (!base::StringToInt64(a.ToString(), &first)) return 1; |
| 70 if (!base::StringToInt64(b.ToString(), &second)) return -1; |
| 71 if (first < second) return -1; |
| 72 if (first > second) return 1; |
| 73 return 0; |
| 74 } |
| 75 const char* Name() const override { return "DigitsComparator"; } |
| 76 void FindShortestSeparator(std::string*, |
| 77 const leveldb::Slice&) const override { } |
| 78 void FindShortSuccessor(std::string*) const override { } |
| 79 }; |
| 80 |
| 81 DeltaFileBackend::DeltaFileBackend(const base::FilePath& dir) |
| 82 : path_(dir.Append(kDbFileName)), |
| 83 leveldb_cmp_(new DeltaFileBackend::DigitsComparator()) { |
| 84 } |
| 85 |
| 86 DeltaFileBackend::~DeltaFileBackend() {} |
| 87 |
| 88 bool DeltaFileBackend::Init() { |
| 89 leveldb::Options options; |
| 90 options.create_if_missing = true; |
| 91 options.max_open_files = 0; // Use minimum number of files. |
| 92 options.comparator = leveldb_cmp_.get(); |
| 93 std::string path = path_.value(); |
| 94 leveldb::DB* db = NULL; |
| 95 leveldb::Status status = leveldb::DB::Open(options, path, &db); |
| 96 if (status.IsCorruption()) { |
| 97 LOG(WARNING) << "Deleting possibly-corrupt database"; |
| 98 base::DeleteFile(path_, true); |
| 99 status = leveldb::DB::Open(options, path, &db); |
| 100 } |
| 101 if (status.ok()) { |
| 102 CHECK(db); |
| 103 db_.reset(db); |
| 104 return true; |
| 105 } |
| 106 LOG(WARNING) << "Unable to open " << path_.value() << ": " |
| 107 << status.ToString(); |
| 108 return false; |
| 109 } |
| 110 |
| 111 bool DeltaFileBackend::EnsureInitialized() { |
| 112 if (db_.get()) return true; |
| 113 return Init(); |
| 114 } |
| 115 |
| 116 void DeltaFileBackend::PageAdded(const GURL& url) { |
| 117 if (!EnsureInitialized()) return; |
| 118 SaveChange(db_.get(), url.spec().c_str(), "add"); |
| 119 } |
| 120 |
| 121 void DeltaFileBackend::PageDeleted(const GURL& url) { |
| 122 if (!EnsureInitialized()) return; |
| 123 SaveChange(db_.get(), url.spec().c_str(), "del"); |
| 124 } |
| 125 |
| 126 int64 DeltaFileBackend::Trim(int64 lower_bound) { |
| 127 if (!EnsureInitialized()) return -1; |
| 128 leveldb::ReadOptions read_options; |
| 129 scoped_ptr<leveldb::Iterator> db_iter(db_->NewIterator(read_options)); |
| 130 db_iter->SeekToFirst(); |
| 131 if (!db_iter->Valid()) |
| 132 return -1; |
| 133 history_report::DeltaFileEntry first_entry; |
| 134 leveldb::Slice value_slice = db_iter->value(); |
| 135 if (!first_entry.ParseFromArray(value_slice.data(), value_slice.size())) |
| 136 return -1; |
| 137 int64 min_seq_no = first_entry.seq_no(); |
| 138 db_iter->SeekToLast(); |
| 139 if (!db_iter->Valid()) |
| 140 return -1; |
| 141 history_report::DeltaFileEntry last_entry; |
| 142 value_slice = db_iter->value(); |
| 143 if (!last_entry.ParseFromArray(value_slice.data(), value_slice.size())) |
| 144 return -1; |
| 145 int64 max_seq_no = last_entry.seq_no(); |
| 146 // We want to have at least one entry in delta file left to know |
| 147 // last sequence number in SaveChange. |
| 148 if (max_seq_no <= lower_bound) |
| 149 lower_bound = max_seq_no - 1; |
| 150 leveldb::WriteBatch updates; |
| 151 for (int64 seq_no = min_seq_no; seq_no <= lower_bound; ++seq_no) { |
| 152 std::string key; |
| 153 base::SStringPrintf(&key, "%" PRId64, seq_no); |
| 154 updates.Delete(leveldb::Slice(key)); |
| 155 } |
| 156 |
| 157 leveldb::WriteOptions write_options; |
| 158 leveldb::Status status = db_->Write(write_options, &updates); |
| 159 if (status.ok()) |
| 160 return max_seq_no; |
| 161 LOG(WARNING) << "Trim failed: " << status.ToString(); |
| 162 return -1; |
| 163 } |
| 164 |
| 165 bool DeltaFileBackend::Recreate(const std::vector<std::string>& urls) { |
| 166 if (!EnsureInitialized()) return false; |
| 167 Clear(); |
| 168 int64 seq_no = 1; |
| 169 leveldb::WriteBatch updates; |
| 170 for (std::vector<std::string>::const_iterator it = urls.begin(); |
| 171 it != urls.end(); |
| 172 ++it) { |
| 173 DeltaFileEntry entry; |
| 174 entry.set_seq_no(seq_no); |
| 175 entry.set_url(*it); |
| 176 entry.set_type("add"); |
| 177 std::string key; |
| 178 base::SStringPrintf(&key, "%" PRId64, seq_no); |
| 179 updates.Put(leveldb::Slice(key), |
| 180 leveldb::Slice(entry.SerializeAsString())); |
| 181 ++seq_no; |
| 182 } |
| 183 leveldb::WriteOptions options; |
| 184 leveldb::Status status = db_->Write(options, &updates); |
| 185 if (status.ok()) |
| 186 return true; |
| 187 LOG(WARNING) << "Recreate failed: " << status.ToString(); |
| 188 return false; |
| 189 } |
| 190 |
| 191 scoped_ptr<std::vector<DeltaFileEntryWithData> > DeltaFileBackend::Query( |
| 192 int64 last_seq_no, |
| 193 int32 limit) { |
| 194 if (!EnsureInitialized()) |
| 195 return make_scoped_ptr(new std::vector<DeltaFileEntryWithData>()); |
| 196 std::string start; |
| 197 base::SStringPrintf(&start, "%" PRId64, last_seq_no + 1); |
| 198 leveldb::ReadOptions options; |
| 199 scoped_ptr<leveldb::Iterator> db_it(db_->NewIterator(options)); |
| 200 scoped_ptr<std::vector<DeltaFileEntryWithData> > result( |
| 201 new std::vector<DeltaFileEntryWithData>()); |
| 202 int32 count = 0; |
| 203 for (db_it->Seek(start); db_it->Valid() && count < limit; db_it->Next()) { |
| 204 DeltaFileEntry entry; |
| 205 leveldb::Slice value_slice = db_it->value(); |
| 206 if (!entry.ParseFromArray(value_slice.data(), value_slice.size())) |
| 207 continue; |
| 208 result->push_back(DeltaFileEntryWithData(entry)); |
| 209 ++count; |
| 210 } |
| 211 return result.Pass(); |
| 212 } |
| 213 |
| 214 void DeltaFileBackend::Clear() { |
| 215 if (!EnsureInitialized()) return; |
| 216 db_.reset(); |
| 217 base::DeleteFile(path_, true); |
| 218 Init(); |
| 219 } |
| 220 |
| 221 std::string DeltaFileBackend::Dump() { |
| 222 std::string dump("\n Delta File ["); |
| 223 if (!EnsureInitialized()) { |
| 224 dump.append("not initialized]"); |
| 225 return dump; |
| 226 } |
| 227 dump.append("num pending entries="); |
| 228 leveldb::ReadOptions options; |
| 229 scoped_ptr<leveldb::Iterator> db_it(db_->NewIterator(options)); |
| 230 int num_entries = 0; |
| 231 for (db_it->SeekToFirst(); db_it->Valid(); db_it->Next()) num_entries++; |
| 232 dump.append(base::IntToString(num_entries)); |
| 233 dump.append("]"); |
| 234 return dump; |
| 235 } |
| 236 |
| 237 } // namespace history_report |
OLD | NEW |