mirror of https://github.com/facebook/rocksdb.git
108 lines
3.5 KiB
C++
108 lines
3.5 KiB
C++
// 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).
|
|
|
|
#include <algorithm>
|
|
#include <iostream>
|
|
#include <map>
|
|
#include <string>
|
|
|
|
#include "proto/gen/db_operation.pb.h"
|
|
#include "rocksdb/db.h"
|
|
#include "rocksdb/file_system.h"
|
|
#include "src/libfuzzer/libfuzzer_macro.h"
|
|
#include "util.h"
|
|
|
|
protobuf_mutator::libfuzzer::PostProcessorRegistration<DBOperations> reg = {
|
|
[](DBOperations* input, unsigned int /* seed */) {
|
|
const ROCKSDB_NAMESPACE::Comparator* comparator =
|
|
ROCKSDB_NAMESPACE::BytewiseComparator();
|
|
auto ops = input->mutable_operations();
|
|
// Make sure begin <= end for DELETE_RANGE.
|
|
for (DBOperation& op : *ops) {
|
|
if (op.type() == OpType::DELETE_RANGE) {
|
|
auto begin = op.key();
|
|
auto end = op.value();
|
|
if (comparator->Compare(begin, end) > 0) {
|
|
std::swap(begin, end);
|
|
op.set_key(begin);
|
|
op.set_value(end);
|
|
}
|
|
}
|
|
}
|
|
}};
|
|
|
|
// Execute randomly generated operations on both a DB and a std::map,
|
|
// then reopen the DB and make sure that iterating the DB produces the
|
|
// same key-value pairs as iterating through the std::map.
|
|
DEFINE_PROTO_FUZZER(DBOperations& input) {
|
|
if (input.operations().empty()) {
|
|
return;
|
|
}
|
|
|
|
const std::string kDbPath = "/tmp/db_map_fuzzer_test";
|
|
auto fs = ROCKSDB_NAMESPACE::FileSystem::Default();
|
|
if (fs->FileExists(kDbPath, ROCKSDB_NAMESPACE::IOOptions(), /*dbg=*/nullptr)
|
|
.ok()) {
|
|
std::cerr << "db path " << kDbPath << " already exists" << std::endl;
|
|
abort();
|
|
}
|
|
|
|
std::map<std::string, std::string> kv;
|
|
ROCKSDB_NAMESPACE::DB* db = nullptr;
|
|
ROCKSDB_NAMESPACE::Options options;
|
|
options.create_if_missing = true;
|
|
CHECK_OK(ROCKSDB_NAMESPACE::DB::Open(options, kDbPath, &db));
|
|
|
|
for (const DBOperation& op : input.operations()) {
|
|
switch (op.type()) {
|
|
case OpType::PUT: {
|
|
CHECK_OK(
|
|
db->Put(ROCKSDB_NAMESPACE::WriteOptions(), op.key(), op.value()));
|
|
kv[op.key()] = op.value();
|
|
break;
|
|
}
|
|
case OpType::MERGE: {
|
|
break;
|
|
}
|
|
case OpType::DELETE: {
|
|
CHECK_OK(db->Delete(ROCKSDB_NAMESPACE::WriteOptions(), op.key()));
|
|
kv.erase(op.key());
|
|
break;
|
|
}
|
|
case OpType::DELETE_RANGE: {
|
|
// [op.key(), op.value()) corresponds to [begin, end).
|
|
CHECK_OK(db->DeleteRange(ROCKSDB_NAMESPACE::WriteOptions(),
|
|
db->DefaultColumnFamily(), op.key(),
|
|
op.value()));
|
|
kv.erase(kv.lower_bound(op.key()), kv.lower_bound(op.value()));
|
|
break;
|
|
}
|
|
default: {
|
|
std::cerr << "Unsupported operation" << static_cast<int>(op.type());
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
CHECK_OK(db->Close());
|
|
delete db;
|
|
db = nullptr;
|
|
|
|
CHECK_OK(ROCKSDB_NAMESPACE::DB::Open(options, kDbPath, &db));
|
|
auto kv_it = kv.begin();
|
|
ROCKSDB_NAMESPACE::Iterator* it =
|
|
db->NewIterator(ROCKSDB_NAMESPACE::ReadOptions());
|
|
for (it->SeekToFirst(); it->Valid(); it->Next(), kv_it++) {
|
|
CHECK_TRUE(kv_it != kv.end());
|
|
CHECK_EQ(it->key().ToString(), kv_it->first);
|
|
CHECK_EQ(it->value().ToString(), kv_it->second);
|
|
}
|
|
CHECK_TRUE(kv_it == kv.end());
|
|
delete it;
|
|
|
|
CHECK_OK(db->Close());
|
|
delete db;
|
|
CHECK_OK(ROCKSDB_NAMESPACE::DestroyDB(kDbPath, options));
|
|
}
|