@nxtedition/rocksdb 7.1.29 → 7.1.31

package/deps/rocksdb/rocksdb/utilities/backup/backup_engine_test.cc

@@ -63,8 +63,11 @@ class DummyDB : public StackableDB {
  public:
   /* implicit */
   DummyDB(const Options& options, const std::string& dbname)
-     : StackableDB(nullptr), options_(options), dbname_(dbname),
-       deletions_enabled_(true), sequence_number_(0) {}
+      : StackableDB(nullptr),
+        options_(options),
+        dbname_(dbname),
+        deletions_enabled_(true),
+        sequence_number_(0) {}
 
   SequenceNumber GetLatestSequenceNumber() const override {
     return ++sequence_number_;
@@ -139,7 +142,7 @@ class DummyDB : public StackableDB {
   std::string dbname_;
   bool deletions_enabled_;
   mutable SequenceNumber sequence_number_;
-}; // DummyDB
+};  // DummyDB
 
 class TestFs : public FileSystemWrapper {
  public:
@@ -545,7 +548,7 @@ class FileManager : public EnvWrapper {
 
  private:
   Random rnd_;
-}; // FileManager
+};  // FileManager
 
 // utility functions
 namespace {
@@ -608,8 +611,8 @@ class BackupEngineTest : public testing::Test {
     kShareWithChecksum,
   };
 
-  const std::vector<ShareOption> kAllShareOptions = {
-      kNoShare, kShareNoChecksum, kShareWithChecksum};
+  const std::vector<ShareOption> kAllShareOptions = {kNoShare, kShareNoChecksum,
+                                                     kShareWithChecksum};
 
   BackupEngineTest() {
     // set up files
@@ -632,7 +635,7 @@ class BackupEngineTest : public testing::Test {
     // set up db options
     options_.create_if_missing = true;
     options_.paranoid_checks = true;
-    options_.write_buffer_size = 1 << 17; // 128KB
+    options_.write_buffer_size = 1 << 17;  // 128KB
     options_.wal_dir = dbname_;
     options_.enable_blob_files = true;
 
@@ -3540,107 +3543,106 @@ TEST_F(BackupEngineTest, Concurrency) {
   std::array<std::thread, 4> restore_verify_threads;
   for (uint32_t i = 0; i < read_threads.size(); ++i) {
     uint32_t sleep_micros = rng() % 100000;
-    read_threads[i] =
-        std::thread([this, i, sleep_micros, &db_opts, &be_opts,
-                     &restore_verify_threads, &limiter] {
-          test_db_env_->SleepForMicroseconds(sleep_micros);
-
-          // Whether to also re-open the BackupEngine, potentially seeing
-          // additional backups
-          bool reopen = i == 3;
-          // Whether we are going to restore "latest"
-          bool latest = i > 1;
-
-          BackupEngine* my_be;
-          if (reopen) {
-            ASSERT_OK(BackupEngine::Open(test_db_env_.get(), be_opts, &my_be));
-          } else {
-            my_be = backup_engine_.get();
-          }
+    read_threads[i] = std::thread([this, i, sleep_micros, &db_opts, &be_opts,
+                                   &restore_verify_threads, &limiter] {
+      test_db_env_->SleepForMicroseconds(sleep_micros);
 
-          // Verify metadata (we don't receive updates from concurrently
-          // creating a new backup)
-          std::vector<BackupInfo> infos;
-          my_be->GetBackupInfo(&infos);
-          const uint32_t count = static_cast<uint32_t>(infos.size());
-          infos.clear();
-          if (reopen) {
-            ASSERT_GE(count, 2U);
-            ASSERT_LE(count, 4U);
-            fprintf(stderr, "Reopen saw %u backups\n", count);
-          } else {
-            ASSERT_EQ(count, 2U);
-          }
-          std::vector<BackupID> ids;
-          my_be->GetCorruptedBackups(&ids);
-          ASSERT_EQ(ids.size(), 0U);
-
-          // (Eventually, see below) Restore one of the backups, or "latest"
-          std::string restore_db_dir = dbname_ + "/restore" + std::to_string(i);
-          DestroyDir(test_db_env_.get(), restore_db_dir).PermitUncheckedError();
-          BackupID to_restore;
-          if (latest) {
-            to_restore = count;
-          } else {
-            to_restore = i + 1;
-          }
+      // Whether to also re-open the BackupEngine, potentially seeing
+      // additional backups
+      bool reopen = i == 3;
+      // Whether we are going to restore "latest"
+      bool latest = i > 1;
 
-          // Open restored DB to verify its contents, but test atomic restore
-          // by doing it async and ensuring we either get OK or InvalidArgument
-          restore_verify_threads[i] =
-              std::thread([this, &db_opts, restore_db_dir, to_restore] {
-                DB* restored;
-                Status s;
-                for (;;) {
-                  s = DB::Open(db_opts, restore_db_dir, &restored);
-                  if (s.IsInvalidArgument()) {
-                    // Restore hasn't finished
-                    test_db_env_->SleepForMicroseconds(1000);
-                    continue;
-                  } else {
-                    // We should only get InvalidArgument if restore is
-                    // incomplete, or OK if complete
-                    ASSERT_OK(s);
-                    break;
-                  }
-                }
-                int factor = std::min(static_cast<int>(to_restore), max_factor);
-                AssertExists(restored, 0, factor * keys_iteration);
-                AssertEmpty(restored, factor * keys_iteration,
-                            (factor + 1) * keys_iteration);
-                delete restored;
-              });
-
-          // (Ok now) Restore one of the backups, or "latest"
-          if (latest) {
-            ASSERT_OK(my_be->RestoreDBFromLatestBackup(restore_db_dir,
-                                                       restore_db_dir));
-          } else {
-            ASSERT_OK(my_be->VerifyBackup(to_restore, true));
-            ASSERT_OK(my_be->RestoreDBFromBackup(to_restore, restore_db_dir,
-                                                 restore_db_dir));
-          }
+      BackupEngine* my_be;
+      if (reopen) {
+        ASSERT_OK(BackupEngine::Open(test_db_env_.get(), be_opts, &my_be));
+      } else {
+        my_be = backup_engine_.get();
+      }
 
-          // Test for race condition in reconfiguring limiter
-          // FIXME: this could set to a different value in all threads, except
-          // GenericRateLimiter::SetBytesPerSecond has a write-write race
-          // reported by TSAN
-          if (i == 0) {
-            limiter->SetBytesPerSecond(2000000000);
-          }
+      // Verify metadata (we don't receive updates from concurrently
+      // creating a new backup)
+      std::vector<BackupInfo> infos;
+      my_be->GetBackupInfo(&infos);
+      const uint32_t count = static_cast<uint32_t>(infos.size());
+      infos.clear();
+      if (reopen) {
+        ASSERT_GE(count, 2U);
+        ASSERT_LE(count, 4U);
+        fprintf(stderr, "Reopen saw %u backups\n", count);
+      } else {
+        ASSERT_EQ(count, 2U);
+      }
+      std::vector<BackupID> ids;
+      my_be->GetCorruptedBackups(&ids);
+      ASSERT_EQ(ids.size(), 0U);
+
+      // (Eventually, see below) Restore one of the backups, or "latest"
+      std::string restore_db_dir = dbname_ + "/restore" + std::to_string(i);
+      DestroyDir(test_db_env_.get(), restore_db_dir).PermitUncheckedError();
+      BackupID to_restore;
+      if (latest) {
+        to_restore = count;
+      } else {
+        to_restore = i + 1;
+      }
 
-          // Re-verify metadata (we don't receive updates from concurrently
-          // creating a new backup)
-          my_be->GetBackupInfo(&infos);
-          ASSERT_EQ(infos.size(), count);
-          my_be->GetCorruptedBackups(&ids);
-          ASSERT_EQ(ids.size(), 0);
-          // fprintf(stderr, "Finished read thread\n");
+      // Open restored DB to verify its contents, but test atomic restore
+      // by doing it async and ensuring we either get OK or InvalidArgument
+      restore_verify_threads[i] =
+          std::thread([this, &db_opts, restore_db_dir, to_restore] {
+            DB* restored;
+            Status s;
+            for (;;) {
+              s = DB::Open(db_opts, restore_db_dir, &restored);
+              if (s.IsInvalidArgument()) {
+                // Restore hasn't finished
+                test_db_env_->SleepForMicroseconds(1000);
+                continue;
+              } else {
+                // We should only get InvalidArgument if restore is
+                // incomplete, or OK if complete
+                ASSERT_OK(s);
+                break;
+              }
+            }
+            int factor = std::min(static_cast<int>(to_restore), max_factor);
+            AssertExists(restored, 0, factor * keys_iteration);
+            AssertEmpty(restored, factor * keys_iteration,
+                        (factor + 1) * keys_iteration);
+            delete restored;
+          });
+
+      // (Ok now) Restore one of the backups, or "latest"
+      if (latest) {
+        ASSERT_OK(
+            my_be->RestoreDBFromLatestBackup(restore_db_dir, restore_db_dir));
+      } else {
+        ASSERT_OK(my_be->VerifyBackup(to_restore, true));
+        ASSERT_OK(my_be->RestoreDBFromBackup(to_restore, restore_db_dir,
+                                             restore_db_dir));
+      }
 
-          if (reopen) {
-            delete my_be;
-          }
-        });
+      // Test for race condition in reconfiguring limiter
+      // FIXME: this could set to a different value in all threads, except
+      // GenericRateLimiter::SetBytesPerSecond has a write-write race
+      // reported by TSAN
+      if (i == 0) {
+        limiter->SetBytesPerSecond(2000000000);
+      }
+
+      // Re-verify metadata (we don't receive updates from concurrently
+      // creating a new backup)
+      my_be->GetBackupInfo(&infos);
+      ASSERT_EQ(infos.size(), count);
+      my_be->GetCorruptedBackups(&ids);
+      ASSERT_EQ(ids.size(), 0);
+      // fprintf(stderr, "Finished read thread\n");
+
+      if (reopen) {
+        delete my_be;
+      }
+    });
   }
 
   BackupEngine* alt_be;
@@ -4196,7 +4198,7 @@ TEST_F(BackupEngineTest, FileTemperatures) {
   }
 }
 
-}  // anon namespace
+}  // namespace
 
 }  // namespace ROCKSDB_NAMESPACE
 

package/deps/rocksdb/rocksdb/utilities/blob_db/blob_db.h

@@ -155,8 +155,7 @@ class BlobDB : public StackableDB {
 
   using ROCKSDB_NAMESPACE::StackableDB::MultiGet;
   virtual std::vector<Status> MultiGet(
-      const ReadOptions& options,
-      const std::vector<Slice>& keys,
+      const ReadOptions& options, const std::vector<Slice>& keys,
       std::vector<std::string>* values) override = 0;
   virtual std::vector<Status> MultiGet(
       const ReadOptions& options,
@@ -179,8 +178,8 @@ class BlobDB : public StackableDB {
                         PinnableSlice* /*values*/, Status* statuses,
                         const bool /*sorted_input*/ = false) override {
     for (size_t i = 0; i < num_keys; ++i) {
-      statuses[i] = Status::NotSupported(
-          "Blob DB doesn't support batched MultiGet");
+      statuses[i] =
+          Status::NotSupported("Blob DB doesn't support batched MultiGet");
     }
   }
 

package/deps/rocksdb/rocksdb/utilities/blob_db/blob_db_impl.cc

@@ -6,6 +6,7 @@
 #ifndef ROCKSDB_LITE
 
 #include "utilities/blob_db/blob_db_impl.h"
+
 #include <algorithm>
 #include <cinttypes>
 #include <iomanip>
@@ -1023,9 +1024,8 @@ Status BlobDBImpl::Put(const WriteOptions& options, const Slice& key,
   return PutUntil(options, key, value, kNoExpiration);
 }
 
-Status BlobDBImpl::PutWithTTL(const WriteOptions& options,
-                              const Slice& key, const Slice& value,
-                              uint64_t ttl) {
+Status BlobDBImpl::PutWithTTL(const WriteOptions& options, const Slice& key,
+                              const Slice& value, uint64_t ttl) {
   uint64_t now = EpochNow();
   uint64_t expiration = kNoExpiration - now > ttl ? now + ttl : kNoExpiration;
   return PutUntil(options, key, value, expiration);
@@ -1385,9 +1385,9 @@ Status BlobDBImpl::AppendBlob(const std::shared_ptr<BlobFile>& bfile,
   return s;
 }
 
-std::vector<Status> BlobDBImpl::MultiGet(
-    const ReadOptions& read_options,
-    const std::vector<Slice>& keys, std::vector<std::string>* values) {
+std::vector<Status> BlobDBImpl::MultiGet(const ReadOptions& read_options,
+                                         const std::vector<Slice>& keys,
+                                         std::vector<std::string>* values) {
   StopWatch multiget_sw(clock_, statistics_, BLOB_DB_MULTIGET_MICROS);
   RecordTick(statistics_, BLOB_DB_NUM_MULTIGET);
   // Get a snapshot to avoid blob file get deleted between we

package/deps/rocksdb/rocksdb/utilities/blob_db/blob_db_impl.h

@@ -124,8 +124,7 @@ class BlobDBImpl : public BlobDB {
 
   using BlobDB::MultiGet;
   virtual std::vector<Status> MultiGet(
-      const ReadOptions& read_options,
-      const std::vector<Slice>& keys,
+      const ReadOptions& read_options, const std::vector<Slice>& keys,
       std::vector<std::string>* values) override;
 
   using BlobDB::Write;

package/deps/rocksdb/rocksdb/utilities/blob_db/blob_db_test.cc

@@ -58,8 +58,7 @@ class BlobDBTest : public testing::Test {
   };
 
   BlobDBTest()
-      : dbname_(test::PerThreadDBPath("blob_db_test")),
-        blob_db_(nullptr) {
+      : dbname_(test::PerThreadDBPath("blob_db_test")), blob_db_(nullptr) {
     mock_clock_ = std::make_shared<MockSystemClock>(SystemClock::Default());
     mock_env_.reset(new CompositeEnvWrapper(Env::Default(), mock_clock_));
     fault_injection_env_.reset(new FaultInjectionTestEnv(Env::Default()));
@@ -209,7 +208,7 @@ class BlobDBTest : public testing::Test {
 
   void VerifyDB(DB *db, const std::map<std::string, std::string> &data) {
     // Verify normal Get
-    auto* cfh = db->DefaultColumnFamily();
+    auto *cfh = db->DefaultColumnFamily();
     for (auto &p : data) {
       PinnableSlice value_slice;
       ASSERT_OK(db->Get(ReadOptions(), cfh, p.first, &value_slice));
@@ -2391,7 +2390,7 @@ TEST_F(BlobDBTest, SyncBlobFileBeforeCloseIOError) {
 }  // namespace ROCKSDB_NAMESPACE
 
 // A black-box test for the ttl wrapper around rocksdb
-int main(int argc, char** argv) {
+int main(int argc, char **argv) {
   ROCKSDB_NAMESPACE::port::InstallStackTraceHandler();
   ::testing::InitGoogleTest(&argc, argv);
   return RUN_ALL_TESTS();

package/deps/rocksdb/rocksdb/utilities/blob_db/blob_dump_tool.cc

@@ -226,7 +226,9 @@ Status BlobDumpTool::DumpRecord(DisplayType show_key, DisplayType show_blob,
     DumpSlice(Slice(slice.data(), static_cast<size_t>(key_size)), show_key);
     if (show_blob != DisplayType::kNone) {
       fprintf(stdout, "  blob       : ");
-      DumpSlice(Slice(slice.data() + static_cast<size_t>(key_size), static_cast<size_t>(value_size)), show_blob);
+      DumpSlice(Slice(slice.data() + static_cast<size_t>(key_size),
+                      static_cast<size_t>(value_size)),
+                show_blob);
     }
     if (show_uncompressed_blob != DisplayType::kNone) {
       fprintf(stdout, "  raw blob   : ");

package/deps/rocksdb/rocksdb/utilities/blob_db/blob_file.cc

@@ -7,9 +7,9 @@
 #include "utilities/blob_db/blob_file.h"
 
 #include <stdio.h>
-#include <cinttypes>
 
 #include <algorithm>
+#include <cinttypes>
 #include <memory>
 
 #include "db/column_family.h"
@@ -210,16 +210,14 @@ Status BlobFile::ReadMetadata(const std::shared_ptr<FileSystem>& fs,
     file_size_ = file_size;
   } else {
     ROCKS_LOG_ERROR(info_log_,
-                    "Failed to get size of blob file %" PRIu64
-                    ", status: %s",
+                    "Failed to get size of blob file %" PRIu64 ", status: %s",
                     file_number_, s.ToString().c_str());
     return s;
   }
   if (file_size < BlobLogHeader::kSize) {
-    ROCKS_LOG_ERROR(info_log_,
-                    "Incomplete blob file blob file %" PRIu64
-                    ", size: %" PRIu64,
-                    file_number_, file_size);
+    ROCKS_LOG_ERROR(
+        info_log_, "Incomplete blob file blob file %" PRIu64 ", size: %" PRIu64,
+        file_number_, file_size);
     return Status::Corruption("Incomplete blob file header.");
   }
 
@@ -250,10 +248,9 @@ Status BlobFile::ReadMetadata(const std::shared_ptr<FileSystem>& fs,
                           Env::IO_TOTAL /* rate_limiter_priority */);
   }
   if (!s.ok()) {
-    ROCKS_LOG_ERROR(info_log_,
-                    "Failed to read header of blob file %" PRIu64
-                    ", status: %s",
-                    file_number_, s.ToString().c_str());
+    ROCKS_LOG_ERROR(
+        info_log_, "Failed to read header of blob file %" PRIu64 ", status: %s",
+        file_number_, s.ToString().c_str());
     return s;
   }
   BlobLogHeader header;
@@ -294,10 +291,9 @@ Status BlobFile::ReadMetadata(const std::shared_ptr<FileSystem>& fs,
                           nullptr, Env::IO_TOTAL /* rate_limiter_priority */);
   }
   if (!s.ok()) {
-    ROCKS_LOG_ERROR(info_log_,
-                    "Failed to read footer of blob file %" PRIu64
-                    ", status: %s",
-                    file_number_, s.ToString().c_str());
+    ROCKS_LOG_ERROR(
+        info_log_, "Failed to read footer of blob file %" PRIu64 ", status: %s",
+        file_number_, s.ToString().c_str());
     return s;
   }
   BlobLogFooter footer;

package/deps/rocksdb/rocksdb/utilities/cache_dump_load_impl.cc

@@ -7,8 +7,6 @@
 #include "table/block_based/block_based_table_reader.h"
 #ifndef ROCKSDB_LITE
 
-#include "utilities/cache_dump_load_impl.h"
-
 #include "cache/cache_entry_roles.h"
 #include "file/writable_file_writer.h"
 #include "port/lang.h"
@@ -17,6 +15,7 @@
 #include "rocksdb/utilities/ldb_cmd.h"
 #include "table/format.h"
 #include "util/crc32c.h"
+#include "utilities/cache_dump_load_impl.h"
 
 namespace ROCKSDB_NAMESPACE {
 

package/deps/rocksdb/rocksdb/utilities/cassandra/cassandra_compaction_filter.cc

@@ -40,8 +40,8 @@ CompactionFilter::Decision CassandraCompactionFilter::FilterV2(
     const Slice& existing_value, std::string* new_value,
     std::string* /*skip_until*/) const {
   bool value_changed = false;
-  RowValue row_value = RowValue::Deserialize(
-    existing_value.data(), existing_value.size());
+  RowValue row_value =
+      RowValue::Deserialize(existing_value.data(), existing_value.size());
   RowValue compacted =
       options_.purge_ttl_on_expiration
           ? row_value.RemoveExpiredColumns(&value_changed)
@@ -51,7 +51,7 @@ CompactionFilter::Decision CassandraCompactionFilter::FilterV2(
     compacted = compacted.RemoveTombstones(options_.gc_grace_period_in_seconds);
   }
 
-  if(compacted.Empty()) {
+  if (compacted.Empty()) {
     return Decision::kRemove;
   }
 

package/deps/rocksdb/rocksdb/utilities/cassandra/cassandra_compaction_filter.h

@@ -25,18 +25,18 @@ namespace cassandra {
  * promoted to kValue type after serials of merging in compaction.
  */
 class CassandraCompactionFilter : public CompactionFilter {
-public:
- explicit CassandraCompactionFilter(bool purge_ttl_on_expiration,
-                                    int32_t gc_grace_period_in_seconds);
- static const char* kClassName() { return "CassandraCompactionFilter"; }
- const char* Name() const override { return kClassName(); }
-
- virtual Decision FilterV2(int level, const Slice& key, ValueType value_type,
-                           const Slice& existing_value, std::string* new_value,
-                           std::string* skip_until) const override;
-
-private:
- CassandraOptions options_;
+ public:
+  explicit CassandraCompactionFilter(bool purge_ttl_on_expiration,
+                                     int32_t gc_grace_period_in_seconds);
+  static const char* kClassName() { return "CassandraCompactionFilter"; }
+  const char* Name() const override { return kClassName(); }
+
+  virtual Decision FilterV2(int level, const Slice& key, ValueType value_type,
+                            const Slice& existing_value, std::string* new_value,
+                            std::string* skip_until) const override;
+
+ private:
+  CassandraOptions options_;
 };
 
 class CassandraCompactionFilterFactory : public CompactionFilterFactory {