diff --git a/CMakeLists.txt b/CMakeLists.txt index 00756e8e3..bc8eb5d61 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -476,7 +476,6 @@ set(SOURCES utilities/backupable/backupable_db.cc utilities/blob_db/blob_db.cc utilities/blob_db/blob_db_impl.cc - utilities/blob_db/blob_db_options_impl.cc utilities/blob_db/blob_dump_tool.cc utilities/blob_db/blob_file.cc utilities/blob_db/blob_log_reader.cc diff --git a/TARGETS b/TARGETS index 525e5d38b..f2aa661f3 100644 --- a/TARGETS +++ b/TARGETS @@ -206,7 +206,6 @@ cpp_library( "utilities/backupable/backupable_db.cc", "utilities/blob_db/blob_db.cc", "utilities/blob_db/blob_db_impl.cc", - "utilities/blob_db/blob_db_options_impl.cc", "utilities/blob_db/blob_file.cc", "utilities/blob_db/blob_log_reader.cc", "utilities/blob_db/blob_log_writer.cc", diff --git a/src.mk b/src.mk index 014287ce0..81d78eb36 100644 --- a/src.mk +++ b/src.mk @@ -154,7 +154,6 @@ LIB_SOURCES = \ utilities/backupable/backupable_db.cc \ utilities/blob_db/blob_db.cc \ utilities/blob_db/blob_db_impl.cc \ - utilities/blob_db/blob_db_options_impl.cc \ utilities/blob_db/blob_file.cc \ utilities/blob_db/blob_log_reader.cc \ utilities/blob_db/blob_log_writer.cc \ diff --git a/tools/db_bench_tool.cc b/tools/db_bench_tool.cc index a1c6af029..8f3ae3536 100644 --- a/tools/db_bench_tool.cc +++ b/tools/db_bench_tool.cc @@ -3311,10 +3311,7 @@ void VerifyDBFromDB(std::string& truth_db_name) { } else if (FLAGS_use_blob_db) { blob_db::BlobDBOptions blob_db_options; blob_db::BlobDB* ptr; - s = CreateLoggerFromOptions(db_name, options, &options.info_log); - if (s.ok()) { - s = blob_db::BlobDB::Open(options, blob_db_options, db_name, &ptr); - } + s = blob_db::BlobDB::Open(options, blob_db_options, db_name, &ptr); if (s.ok()) { db->db = ptr; } diff --git a/utilities/blob_db/blob_db.cc b/utilities/blob_db/blob_db.cc index ea60ad59b..4f95b61f2 100644 --- a/utilities/blob_db/blob_db.cc +++ b/utilities/blob_db/blob_db.cc @@ -5,7 +5,14 @@ // #ifndef ROCKSDB_LITE +#ifndef __STDC_FORMAT_MACROS +#define __STDC_FORMAT_MACROS +#endif + #include "utilities/blob_db/blob_db.h" + +#include + #include "db/write_batch_internal.h" #include "monitoring/instrumented_mutex.h" #include "options/cf_options.h" @@ -94,23 +101,31 @@ Status BlobDB::Open(const Options& options, const BlobDBOptions& bdb_options, return s; } -Status BlobDB::Open(const DBOptions& db_options, +Status BlobDB::Open(const DBOptions& db_options_input, const BlobDBOptions& bdb_options, const std::string& dbname, const std::vector& column_families, std::vector* handles, BlobDB** blob_db, bool no_base_db) { *blob_db = nullptr; + Status s; + + DBOptions db_options(db_options_input); + if (db_options.info_log == nullptr) { + s = CreateLoggerFromOptions(dbname, db_options, &db_options.info_log); + if (!s.ok()) { + return s; + } + } - DBOptions my_db_options(db_options); FlushBeginListener_t fblistener = std::make_shared(); CompactionListener_t ce_listener = std::make_shared(); ReconcileWalFilter_t rw_filter = std::make_shared(); - my_db_options.listeners.emplace_back(fblistener); - my_db_options.listeners.emplace_back(ce_listener); - my_db_options.wal_filter = rw_filter.get(); + db_options.listeners.emplace_back(fblistener); + db_options.listeners.emplace_back(ce_listener); + db_options.wal_filter = rw_filter.get(); { MutexLock l(&listener_mutex); @@ -120,19 +135,25 @@ Status BlobDB::Open(const DBOptions& db_options, } // we need to open blob db first so that recovery can happen - BlobDBImpl* bdb = new BlobDBImpl(dbname, bdb_options, my_db_options); + BlobDBImpl* bdb = new BlobDBImpl(dbname, bdb_options, db_options); fblistener->SetImplPtr(bdb); ce_listener->SetImplPtr(bdb); rw_filter->SetImplPtr(bdb); - Status s = bdb->OpenPhase1(); - if (!s.ok()) return s; + s = bdb->OpenPhase1(); + if (!s.ok()) { + return s; + } - if (no_base_db) return s; + if (no_base_db) { + return s; + } DB* db = nullptr; - s = DB::Open(my_db_options, dbname, column_families, handles, &db); - if (!s.ok()) return s; + s = DB::Open(db_options, dbname, column_families, handles, &db); + if (!s.ok()) { + return s; + } // set the implementation pointer s = bdb->LinkToBaseDB(db); @@ -141,28 +162,36 @@ Status BlobDB::Open(const DBOptions& db_options, bdb = nullptr; } *blob_db = bdb; + bdb_options.Dump(db_options.info_log.get()); return s; } BlobDB::BlobDB(DB* db) : StackableDB(db) {} -//////////////////////////////////////////////////////////////////////////////// -// -// -// std::function fnCaller = -// std::bind(&A::fn, &anInstance, std::placeholders::_1); -//////////////////////////////////////////////////////////////////////////////// -BlobDBOptions::BlobDBOptions() - : blob_dir("blob_dir"), - path_relative(true), - is_fifo(false), - blob_dir_size(1000ULL * 1024ULL * 1024ULL * 1024ULL), - ttl_range_secs(3600), - min_blob_size(512), - bytes_per_sync(0), - blob_file_size(256 * 1024 * 1024), - num_concurrent_simple_blobs(4), - compression(kNoCompression) {} +void BlobDBOptions::Dump(Logger* log) const { + ROCKS_LOG_HEADER(log, " blob_db_options.blob_dir: %s", + blob_dir.c_str()); + ROCKS_LOG_HEADER(log, " blob_db_options.path_relative: %d", + path_relative); + ROCKS_LOG_HEADER(log, " blob_db_options.is_fifo: %d", + is_fifo); + ROCKS_LOG_HEADER(log, " blob_db_options.blob_dir_size: %" PRIu64, + blob_dir_size); + ROCKS_LOG_HEADER(log, " blob_db_options.ttl_range_secs: %" PRIu32, + ttl_range_secs); + ROCKS_LOG_HEADER(log, " blob_db_options.bytes_per_sync: %" PRIu64, + bytes_per_sync); + ROCKS_LOG_HEADER(log, " blob_db_options.blob_file_size: %" PRIu64, + blob_file_size); + ROCKS_LOG_HEADER(log, "blob_db_options.num_concurrent_simple_blobs: %" PRIu32, + num_concurrent_simple_blobs); + ROCKS_LOG_HEADER(log, " blob_db_options.ttl_extractor: %p", + ttl_extractor.get()); + ROCKS_LOG_HEADER(log, " blob_db_options.compression: %d", + static_cast(compression)); + ROCKS_LOG_HEADER(log, " blob_db_options.disable_background_tasks: %d", + disable_background_tasks); +} } // namespace blob_db } // namespace rocksdb diff --git a/utilities/blob_db/blob_db.h b/utilities/blob_db/blob_db.h index e68b40a0a..b645ea6ef 100644 --- a/utilities/blob_db/blob_db.h +++ b/utilities/blob_db/blob_db.h @@ -31,18 +31,18 @@ class TTLExtractor; struct BlobDBOptions { // name of the directory under main db, where blobs will be stored. // default is "blob_dir" - std::string blob_dir; + std::string blob_dir = "blob_dir"; // whether the blob_dir path is relative or absolute. - bool path_relative; + bool path_relative = true; // is the eviction strategy fifo based - bool is_fifo; + bool is_fifo = false; // maximum size of the blob dir. Once this gets used, up // evict the blob file which is oldest (is_fifo ) // 0 means no limits - uint64_t blob_dir_size; + uint64_t blob_dir_size = 0; // a new bucket is opened, for ttl_range. So if ttl_range is 600seconds // (10 minutes), and the first bucket starts at 1471542000 @@ -50,26 +50,22 @@ struct BlobDBOptions { // first bucket is 1471542000 - 1471542600 // second bucket is 1471542600 - 1471543200 // and so on - uint32_t ttl_range_secs; - - // at what size will the blobs be stored in separate log rather than - // inline - uint64_t min_blob_size; + uint32_t ttl_range_secs = 3600; // at what bytes will the blob files be synced to blob log. - uint64_t bytes_per_sync; + uint64_t bytes_per_sync = 0; // the target size of each blob file. File will become immutable // after it exceeds that size - uint64_t blob_file_size; + uint64_t blob_file_size = 256 * 1024 * 1024; // how many files to use for simple blobs at one time - uint32_t num_concurrent_simple_blobs; + uint32_t num_concurrent_simple_blobs = 1; // Instead of setting TTL explicitly by calling PutWithTTL or PutUntil, // applications can set a TTLExtractor which can extract TTL from key-value // pairs. - std::shared_ptr ttl_extractor; + std::shared_ptr ttl_extractor = nullptr; // eviction callback. // this function will be called for every blob that is getting @@ -78,14 +74,12 @@ struct BlobDBOptions { gc_evict_cb_fn; // what compression to use for Blob's - CompressionType compression; - - // default constructor - BlobDBOptions(); + CompressionType compression = kNoCompression; - BlobDBOptions(const BlobDBOptions& in) = default; + // Disable all background job. + bool disable_background_tasks = false; - virtual ~BlobDBOptions() = default; + void Dump(Logger* log) const; }; class BlobDB : public StackableDB { diff --git a/utilities/blob_db/blob_db_impl.cc b/utilities/blob_db/blob_db_impl.cc index f55566fd4..0488d9924 100644 --- a/utilities/blob_db/blob_db_impl.cc +++ b/utilities/blob_db/blob_db_impl.cc @@ -199,12 +199,6 @@ BlobDBImpl::BlobDBImpl(const std::string& dbname, total_blob_space_(0), open_p1_done_(false), debug_level_(0) { - const BlobDBOptionsImpl* options_impl = - static_cast_with_check( - &blob_db_options); - if (options_impl) { - bdb_options_ = *options_impl; - } blob_dir_ = (bdb_options_.path_relative) ? dbname + "/" + bdb_options_.blob_dir : bdb_options_.blob_dir; @@ -263,12 +257,6 @@ BlobDBImpl::BlobDBImpl(DB* db, const BlobDBOptions& blob_db_options) total_periods_write_(0), total_periods_ampl_(0), total_blob_space_(0) { - assert(db_impl_ != nullptr); - const BlobDBOptionsImpl* options_impl = - static_cast_with_check( - &blob_db_options); - bdb_options_ = *options_impl; - if (!bdb_options_.blob_dir.empty()) blob_dir_ = (bdb_options_.path_relative) ? db_->GetName() + "/" + bdb_options_.blob_dir @@ -304,27 +292,27 @@ Status BlobDBImpl::OpenPhase1() { void BlobDBImpl::StartBackgroundTasks() { // store a call to a member function and object tqueue_.add( - bdb_options_.reclaim_of_period_millisecs, + kReclaimOpenFilesPeriodMillisecs, std::bind(&BlobDBImpl::ReclaimOpenFiles, this, std::placeholders::_1)); - tqueue_.add(bdb_options_.gc_check_period_millisecs, + tqueue_.add(kGCCheckPeriodMillisecs, std::bind(&BlobDBImpl::RunGC, this, std::placeholders::_1)); tqueue_.add( - bdb_options_.deletion_check_period_millisecs, + kDeleteCheckPeriodMillisecs, std::bind(&BlobDBImpl::EvictDeletions, this, std::placeholders::_1)); tqueue_.add( - bdb_options_.deletion_check_period_millisecs, + kDeleteCheckPeriodMillisecs, std::bind(&BlobDBImpl::EvictCompacted, this, std::placeholders::_1)); tqueue_.add( - bdb_options_.delete_obsf_period_millisecs, + kDeleteObsoletedFilesPeriodMillisecs, std::bind(&BlobDBImpl::DeleteObsFiles, this, std::placeholders::_1)); - tqueue_.add(bdb_options_.sanity_check_period_millisecs, + tqueue_.add(kSanityCheckPeriodMillisecs, std::bind(&BlobDBImpl::SanityCheck, this, std::placeholders::_1)); - tqueue_.add(bdb_options_.wa_stats_period_millisecs, + tqueue_.add(kWriteAmplificationStatsPeriodMillisecs, std::bind(&BlobDBImpl::WaStats, this, std::placeholders::_1)); - tqueue_.add(bdb_options_.fsync_files_period_millisecs, + tqueue_.add(kFSyncFilesPeriodMillisecs, std::bind(&BlobDBImpl::FsyncFiles, this, std::placeholders::_1)); tqueue_.add( - bdb_options_.check_seqf_period_millisecs, + kCheckSeqFilesPeriodMillisecs, std::bind(&BlobDBImpl::CheckSeqFiles, this, std::placeholders::_1)); } @@ -1606,8 +1594,9 @@ std::pair BlobDBImpl::FsyncFiles(bool aborted) { std::pair BlobDBImpl::ReclaimOpenFiles(bool aborted) { if (aborted) return std::make_pair(false, -1); - if (open_file_count_.load() < bdb_options_.open_files_trigger) + if (open_file_count_.load() < kOpenFilesTrigger) { return std::make_pair(true, -1); + } // in the future, we should sort by last_access_ // instead of closing every file @@ -1628,7 +1617,7 @@ std::pair BlobDBImpl::WaStats(bool aborted) { WriteLock wl(&mutex_); - if (all_periods_write_.size() < bdb_options_.wa_num_stats_periods) { + if (all_periods_write_.size() < kWriteAmplificationStatsPeriods) { total_periods_write_ -= (*all_periods_write_.begin()); total_periods_ampl_ = (*all_periods_ampl_.begin()); @@ -1868,15 +1857,14 @@ bool BlobDBImpl::ShouldGCFile(std::shared_ptr bfile, std::time_t tt, return true; } - if (bdb_options_.ttl_range_secs < - bdb_options_.partial_expiration_gc_range_secs) { + if (bdb_options_.ttl_range_secs < kPartialExpirationGCRangeSecs) { *reason = "has ttl but partial expiration not turned on"; return false; } ReadLock lockbfile_r(&bfile->mutex_); bool ret = ((bfile->deleted_size_ * 100.0 / bfile->file_size_.load()) > - bdb_options_.partial_expiration_pct); + kPartialExpirationPercentage); if (ret) { *reason = "deleted blobs beyond threshold"; } else { @@ -1895,13 +1883,14 @@ bool BlobDBImpl::ShouldGCFile(std::shared_ptr bfile, std::time_t tt, ReadLock lockbfile_r(&bfile->mutex_); if ((bfile->deleted_size_ * 100.0 / bfile->file_size_.load()) > - bdb_options_.partial_expiration_pct) { + kPartialExpirationPercentage) { *reason = "deleted simple blobs beyond threshold"; return true; } // if we haven't reached limits of disk space, don't DELETE - if (total_blob_space_.load() < bdb_options_.blob_dir_size) { + if (bdb_options_.blob_dir_size == 0 || + total_blob_space_.load() < bdb_options_.blob_dir_size) { *reason = "disk space not exceeded"; return false; } @@ -2057,7 +2046,7 @@ void BlobDBImpl::FilterSubsetOfFiles( uint64_t last_id, size_t files_to_collect) { // 100.0 / 15.0 = 7 uint64_t next_epoch_increment = static_cast( - std::ceil(100 / static_cast(bdb_options_.gc_file_pct))); + std::ceil(100 / static_cast(kGCFilePercentage))); std::chrono::system_clock::time_point now = std::chrono::system_clock::now(); std::time_t tt = std::chrono::system_clock::to_time_t(now); @@ -2114,8 +2103,7 @@ std::pair BlobDBImpl::RunGC(bool aborted) { // 15% of files are collected each call to space out the IO and CPU // consumption. - size_t files_to_collect = - (bdb_options_.gc_file_pct * blob_files.size()) / 100; + size_t files_to_collect = (kGCFilePercentage * blob_files.size()) / 100; std::vector> to_process; FilterSubsetOfFiles(blob_files, &to_process, current_epoch_, last_id, diff --git a/utilities/blob_db/blob_db_impl.h b/utilities/blob_db/blob_db_impl.h index 8da5bbf65..95a387afe 100644 --- a/utilities/blob_db/blob_db_impl.h +++ b/utilities/blob_db/blob_db_impl.h @@ -29,7 +29,6 @@ #include "util/mutexlock.h" #include "util/timer_queue.h" #include "utilities/blob_db/blob_db.h" -#include "utilities/blob_db/blob_db_options_impl.h" #include "utilities/blob_db/blob_log_format.h" #include "utilities/blob_db/blob_log_reader.h" #include "utilities/blob_db/blob_log_writer.h" @@ -158,6 +157,51 @@ class BlobDBImpl : public BlobDB { friend class BlobDBIterator; public: + // deletions check period + static constexpr uint32_t kDeleteCheckPeriodMillisecs = 2 * 1000; + + // gc percentage each check period + static constexpr uint32_t kGCFilePercentage = 100; + + // gc period + static constexpr uint32_t kGCCheckPeriodMillisecs = 60 * 1000; + + // sanity check task + static constexpr uint32_t kSanityCheckPeriodMillisecs = 20 * 60 * 1000; + + // how many random access open files can we tolerate + static constexpr uint32_t kOpenFilesTrigger = 100; + + // how many periods of stats do we keep. + static constexpr uint32_t kWriteAmplificationStatsPeriods = 24; + + // what is the length of any period + static constexpr uint32_t kWriteAmplificationStatsPeriodMillisecs = + 3600 * 1000; + + // we will garbage collect blob files in + // which entire files have expired. However if the + // ttl_range of files is very large say a day, we + // would have to wait for the entire day, before we + // recover most of the space. + static constexpr uint32_t kPartialExpirationGCRangeSecs = 4 * 3600; + + // this should be based on allowed Write Amplification + // if 50% of the space of a blob file has been deleted/expired, + static constexpr uint32_t kPartialExpirationPercentage = 75; + + // how often should we schedule a job to fsync open files + static constexpr uint32_t kFSyncFilesPeriodMillisecs = 10 * 1000; + + // how often to schedule reclaim open files. + static constexpr uint32_t kReclaimOpenFilesPeriodMillisecs = 1 * 1000; + + // how often to schedule delete obs files periods + static constexpr uint32_t kDeleteObsoletedFilesPeriodMillisecs = 10 * 1000; + + // how often to schedule check seq files period + static constexpr uint32_t kCheckSeqFilesPeriodMillisecs = 10 * 1000; + static constexpr uint64_t kNoExpiration = std::numeric_limits::max(); @@ -383,7 +427,7 @@ class BlobDBImpl : public BlobDB { WriteOptions write_options_; // the options that govern the behavior of Blob Storage - BlobDBOptionsImpl bdb_options_; + BlobDBOptions bdb_options_; DBOptions db_options_; EnvOptions env_options_; diff --git a/utilities/blob_db/blob_db_options_impl.cc b/utilities/blob_db/blob_db_options_impl.cc deleted file mode 100644 index 263213d8e..000000000 --- a/utilities/blob_db/blob_db_options_impl.cc +++ /dev/null @@ -1,69 +0,0 @@ -// 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). -#ifndef ROCKSDB_LITE - -#include "utilities/blob_db/blob_db_options_impl.h" - -namespace rocksdb { - -namespace blob_db { - -BlobDBOptionsImpl::BlobDBOptionsImpl(const BlobDBOptions& in) - : BlobDBOptions(in), - deletion_check_period_millisecs(2 * 1000), - gc_file_pct(20), - gc_check_period_millisecs(60 * 1000), - sanity_check_period_millisecs(20 * 60 * 1000), - open_files_trigger(100), - wa_num_stats_periods(24), - wa_stats_period_millisecs(3600 * 1000), - partial_expiration_gc_range_secs(4 * 3600), - partial_expiration_pct(75), - fsync_files_period_millisecs(10 * 1000), - reclaim_of_period_millisecs(1 * 1000), - delete_obsf_period_millisecs(10 * 1000), - check_seqf_period_millisecs(10 * 1000), - disable_background_tasks(false) {} - -BlobDBOptionsImpl::BlobDBOptionsImpl() - : deletion_check_period_millisecs(2 * 1000), - gc_file_pct(20), - gc_check_period_millisecs(60 * 1000), - sanity_check_period_millisecs(20 * 60 * 1000), - open_files_trigger(100), - wa_num_stats_periods(24), - wa_stats_period_millisecs(3600 * 1000), - partial_expiration_gc_range_secs(4 * 3600), - partial_expiration_pct(75), - fsync_files_period_millisecs(10 * 1000), - reclaim_of_period_millisecs(1 * 1000), - delete_obsf_period_millisecs(10 * 1000), - check_seqf_period_millisecs(10 * 1000), - disable_background_tasks(false) {} - -BlobDBOptionsImpl& BlobDBOptionsImpl::operator=(const BlobDBOptionsImpl& in) { - BlobDBOptions::operator=(in); - if (this != &in) { - deletion_check_period_millisecs = in.deletion_check_period_millisecs; - gc_file_pct = in.gc_file_pct; - gc_check_period_millisecs = in.gc_check_period_millisecs; - sanity_check_period_millisecs = in.sanity_check_period_millisecs; - open_files_trigger = in.open_files_trigger; - wa_num_stats_periods = in.wa_num_stats_periods; - wa_stats_period_millisecs = in.wa_stats_period_millisecs; - partial_expiration_gc_range_secs = in.partial_expiration_gc_range_secs; - partial_expiration_pct = in.partial_expiration_pct; - fsync_files_period_millisecs = in.fsync_files_period_millisecs; - reclaim_of_period_millisecs = in.reclaim_of_period_millisecs; - delete_obsf_period_millisecs = in.delete_obsf_period_millisecs; - check_seqf_period_millisecs = in.check_seqf_period_millisecs; - disable_background_tasks = in.disable_background_tasks; - } - return *this; -} - -} // namespace blob_db -} // namespace rocksdb -#endif // ROCKSDB_LITE diff --git a/utilities/blob_db/blob_db_options_impl.h b/utilities/blob_db/blob_db_options_impl.h deleted file mode 100644 index 0ee0aa920..000000000 --- a/utilities/blob_db/blob_db_options_impl.h +++ /dev/null @@ -1,76 +0,0 @@ -// 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). - -#pragma once - -#ifndef ROCKSDB_LITE - -#include "utilities/blob_db/blob_db.h" - -namespace rocksdb { - -namespace blob_db { - -struct BlobDBOptionsImpl : public BlobDBOptions { - // deletions check period - uint32_t deletion_check_period_millisecs; - - // gc percentage each check period - uint32_t gc_file_pct; - - // gc period - uint32_t gc_check_period_millisecs; - - // sanity check task - uint32_t sanity_check_period_millisecs; - - // how many random access open files can we tolerate - uint32_t open_files_trigger; - - // how many periods of stats do we keep. - uint32_t wa_num_stats_periods; - - // what is the length of any period - uint32_t wa_stats_period_millisecs; - - // we will garbage collect blob files in - // which entire files have expired. However if the - // ttl_range of files is very large say a day, we - // would have to wait for the entire day, before we - // recover most of the space. - uint32_t partial_expiration_gc_range_secs; - - // this should be based on allowed Write Amplification - // if 50% of the space of a blob file has been deleted/expired, - uint32_t partial_expiration_pct; - - // how often should we schedule a job to fsync open files - uint32_t fsync_files_period_millisecs; - - // how often to schedule reclaim open files. - uint32_t reclaim_of_period_millisecs; - - // how often to schedule delete obs files periods - uint32_t delete_obsf_period_millisecs; - - // how often to schedule check seq files period - uint32_t check_seqf_period_millisecs; - - // Disable all background job. - bool disable_background_tasks; - - // default constructor - BlobDBOptionsImpl(); - - explicit BlobDBOptionsImpl(const BlobDBOptions& in); - - BlobDBOptionsImpl& operator=(const BlobDBOptionsImpl& in); -}; - -} // namespace blob_db - -} // namespace rocksdb - -#endif // endif ROCKSDB diff --git a/utilities/blob_db/blob_db_test.cc b/utilities/blob_db/blob_db_test.cc index 6a43f6b77..a5f979592 100644 --- a/utilities/blob_db/blob_db_test.cc +++ b/utilities/blob_db/blob_db_test.cc @@ -16,7 +16,6 @@ #include "util/string_util.h" #include "util/testharness.h" #include "utilities/blob_db/blob_db_impl.h" -#include "utilities/blob_db/blob_db_options_impl.h" namespace rocksdb { namespace blob_db { @@ -47,7 +46,7 @@ class BlobDBTest : public testing::Test { ~BlobDBTest() { Destroy(); } - void Open(BlobDBOptionsImpl bdb_options = BlobDBOptionsImpl(), + void Open(BlobDBOptions bdb_options = BlobDBOptions(), Options options = Options()) { options.create_if_missing = true; ASSERT_OK(BlobDB::Open(options, bdb_options, dbname_, &blob_db_)); @@ -153,7 +152,7 @@ class BlobDBTest : public testing::Test { TEST_F(BlobDBTest, Put) { Random rnd(301); - BlobDBOptionsImpl bdb_options; + BlobDBOptions bdb_options; bdb_options.disable_background_tasks = true; Open(bdb_options); std::map data; @@ -167,7 +166,7 @@ TEST_F(BlobDBTest, PutWithTTL) { Random rnd(301); Options options; options.env = mock_env_.get(); - BlobDBOptionsImpl bdb_options; + BlobDBOptions bdb_options; bdb_options.ttl_range_secs = 1000; bdb_options.blob_file_size = 256 * 1000 * 1000; bdb_options.disable_background_tasks = true; @@ -196,7 +195,7 @@ TEST_F(BlobDBTest, PutUntil) { Random rnd(301); Options options; options.env = mock_env_.get(); - BlobDBOptionsImpl bdb_options; + BlobDBOptions bdb_options; bdb_options.ttl_range_secs = 1000; bdb_options.blob_file_size = 256 * 1000 * 1000; bdb_options.disable_background_tasks = true; @@ -227,7 +226,7 @@ TEST_F(BlobDBTest, TTLExtrator_NoTTL) { Random rnd(301); Options options; options.env = mock_env_.get(); - BlobDBOptionsImpl bdb_options; + BlobDBOptions bdb_options; bdb_options.ttl_range_secs = 1000; bdb_options.blob_file_size = 256 * 1000 * 1000; bdb_options.num_concurrent_simple_blobs = 1; @@ -275,7 +274,7 @@ TEST_F(BlobDBTest, TTLExtractor_ExtractTTL) { ttl_extractor_.reset(new TestTTLExtractor(&rnd)); Options options; options.env = mock_env_.get(); - BlobDBOptionsImpl bdb_options; + BlobDBOptions bdb_options; bdb_options.ttl_range_secs = 1000; bdb_options.blob_file_size = 256 * 1000 * 1000; bdb_options.ttl_extractor = ttl_extractor_; @@ -322,7 +321,7 @@ TEST_F(BlobDBTest, TTLExtractor_ExtractExpiration) { ttl_extractor_.reset(new TestTTLExtractor(&rnd)); Options options; options.env = mock_env_.get(); - BlobDBOptionsImpl bdb_options; + BlobDBOptions bdb_options; bdb_options.ttl_range_secs = 1000; bdb_options.blob_file_size = 256 * 1000 * 1000; bdb_options.ttl_extractor = ttl_extractor_; @@ -369,7 +368,7 @@ TEST_F(BlobDBTest, TTLExtractor_ChangeValue) { Random rnd(301); Options options; options.env = mock_env_.get(); - BlobDBOptionsImpl bdb_options; + BlobDBOptions bdb_options; bdb_options.ttl_range_secs = 1000; bdb_options.blob_file_size = 256 * 1000 * 1000; bdb_options.ttl_extractor = std::make_shared(); @@ -404,7 +403,7 @@ TEST_F(BlobDBTest, TTLExtractor_ChangeValue) { TEST_F(BlobDBTest, StackableDBGet) { Random rnd(301); - BlobDBOptionsImpl bdb_options; + BlobDBOptions bdb_options; bdb_options.disable_background_tasks = true; Open(bdb_options); std::map data; @@ -426,7 +425,7 @@ TEST_F(BlobDBTest, StackableDBGet) { TEST_F(BlobDBTest, WriteBatch) { Random rnd(301); - BlobDBOptionsImpl bdb_options; + BlobDBOptions bdb_options; bdb_options.disable_background_tasks = true; Open(bdb_options); std::map data; @@ -442,7 +441,7 @@ TEST_F(BlobDBTest, WriteBatch) { TEST_F(BlobDBTest, Delete) { Random rnd(301); - BlobDBOptionsImpl bdb_options; + BlobDBOptions bdb_options; bdb_options.disable_background_tasks = true; Open(bdb_options); std::map data; @@ -457,7 +456,7 @@ TEST_F(BlobDBTest, Delete) { TEST_F(BlobDBTest, DeleteBatch) { Random rnd(301); - BlobDBOptionsImpl bdb_options; + BlobDBOptions bdb_options; bdb_options.disable_background_tasks = true; Open(bdb_options); for (size_t i = 0; i < 100; i++) { @@ -474,7 +473,7 @@ TEST_F(BlobDBTest, DeleteBatch) { TEST_F(BlobDBTest, Override) { Random rnd(301); - BlobDBOptionsImpl bdb_options; + BlobDBOptions bdb_options; bdb_options.disable_background_tasks = true; Open(bdb_options); std::map data; @@ -491,7 +490,7 @@ TEST_F(BlobDBTest, Override) { #ifdef SNAPPY TEST_F(BlobDBTest, Compression) { Random rnd(301); - BlobDBOptionsImpl bdb_options; + BlobDBOptions bdb_options; bdb_options.disable_background_tasks = true; bdb_options.compression = CompressionType::kSnappyCompression; Open(bdb_options); @@ -528,7 +527,7 @@ TEST_F(BlobDBTest, DISABLED_MultipleWriters) { // Test sequence number store in blob file is correct. TEST_F(BlobDBTest, SequenceNumber) { Random rnd(301); - BlobDBOptionsImpl bdb_options; + BlobDBOptions bdb_options; bdb_options.disable_background_tasks = true; Open(bdb_options); SequenceNumber sequence = blob_db_->GetLatestSequenceNumber();