@nxtedition/rocksdb 10.0.13 → 10.0.15

package/deps/rocksdb/rocksdb/env/composite_env.cc

@@ -504,7 +504,7 @@ EnvWrapper::EnvWrapper(const std::shared_ptr<Env>& t) : target_(t) {
   RegisterOptions("", &target_, &env_wrapper_type_info);
 }
 
-EnvWrapper::~EnvWrapper() {}
+EnvWrapper::~EnvWrapper() = default;
 
 Status EnvWrapper::PrepareOptions(const ConfigOptions& options) {
   target_.Prepare();

package/deps/rocksdb/rocksdb/env/emulated_clock.h

@@ -34,7 +34,7 @@ class EmulatedSystemClock : public SystemClockWrapper {
   static const char* kClassName() { return "TimeEmulatedSystemClock"; }
   const char* Name() const override { return kClassName(); }
 
-  virtual void SleepForMicroseconds(int micros) override {
+  void SleepForMicroseconds(int micros) override {
     sleep_counter_++;
     if (no_slowdown_ || time_elapse_only_sleep_) {
       addon_microseconds_.fetch_add(micros);
@@ -70,7 +70,7 @@ class EmulatedSystemClock : public SystemClockWrapper {
 
   int GetSleepCounter() const { return sleep_counter_.load(); }
 
-  virtual Status GetCurrentTime(int64_t* unix_time) override {
+  Status GetCurrentTime(int64_t* unix_time) override {
     Status s;
     if (time_elapse_only_sleep_) {
       *unix_time = maybe_starting_time_;
@@ -84,22 +84,22 @@ class EmulatedSystemClock : public SystemClockWrapper {
     return s;
   }
 
-  virtual uint64_t CPUNanos() override {
+  uint64_t CPUNanos() override {
     cpu_counter_++;
     return SystemClockWrapper::CPUNanos();
   }
 
-  virtual uint64_t CPUMicros() override {
+  uint64_t CPUMicros() override {
     cpu_counter_++;
     return SystemClockWrapper::CPUMicros();
   }
 
-  virtual uint64_t NowNanos() override {
+  uint64_t NowNanos() override {
     return (time_elapse_only_sleep_ ? 0 : SystemClockWrapper::NowNanos()) +
            addon_microseconds_.load() * 1000;
   }
 
-  virtual uint64_t NowMicros() override {
+  uint64_t NowMicros() override {
     return (time_elapse_only_sleep_ ? 0 : SystemClockWrapper::NowMicros()) +
            addon_microseconds_.load();
   }

package/deps/rocksdb/rocksdb/env/env.cc

@@ -359,7 +359,7 @@ class LegacyFileSystemWrapper : public FileSystem {
  public:
   // Initialize an EnvWrapper that delegates all calls to *t
   explicit LegacyFileSystemWrapper(Env* t) : target_(t) {}
-  ~LegacyFileSystemWrapper() override {}
+  ~LegacyFileSystemWrapper() override = default;
 
   static const char* kClassName() { return "LegacyFileSystem"; }
   const char* Name() const override { return kClassName(); }
@@ -624,7 +624,7 @@ Env::Env(const std::shared_ptr<FileSystem>& fs,
          const std::shared_ptr<SystemClock>& clock)
     : thread_status_updater_(nullptr), file_system_(fs), system_clock_(clock) {}
 
-Env::~Env() {}
+Env::~Env() = default;
 
 Status Env::NewLogger(const std::string& fname,
                       std::shared_ptr<Logger>* result) {
@@ -797,7 +797,7 @@ std::string Env::GenerateUniqueId() {
 
     // Use 36 character format of RFC 4122
     result.resize(36U);
-    char* buf = &result[0];
+    char* buf = result.data();
     PutBaseChars<16>(&buf, 8, upper >> 32, /*!uppercase*/ false);
     *(buf++) = '-';
     PutBaseChars<16>(&buf, 4, upper >> 16, /*!uppercase*/ false);
@@ -817,15 +817,24 @@ std::string Env::GenerateUniqueId() {
   return result;
 }
 
-SequentialFile::~SequentialFile() {}
+SequentialFile::~SequentialFile() = default;
 
-RandomAccessFile::~RandomAccessFile() {}
+RandomAccessFile::~RandomAccessFile() = default;
 
-WritableFile::~WritableFile() {}
+WritableFile::~WritableFile() = default;
 
-MemoryMappedFileBuffer::~MemoryMappedFileBuffer() {}
+MemoryMappedFileBuffer::~MemoryMappedFileBuffer() = default;
 
-Logger::~Logger() {}
+// This const variable can be used in public headers without introducing the
+// possibility of ODR violations due to varying macro definitions.
+const InfoLogLevel Logger::kDefaultLogLevel =
+#ifdef NDEBUG
+    INFO_LEVEL;
+#else
+    DEBUG_LEVEL;
+#endif  // NDEBUG
+
+Logger::~Logger() = default;
 
 Status Logger::Close() {
   if (!closed_) {
@@ -838,7 +847,7 @@ Status Logger::Close() {
 
 Status Logger::CloseImpl() { return Status::NotSupported(); }
 
-FileLock::~FileLock() {}
+FileLock::~FileLock() = default;
 
 void LogFlush(Logger* info_log) {
   if (info_log) {
@@ -1051,9 +1060,10 @@ void Log(const std::shared_ptr<Logger>& info_log, const char* format, ...) {
 }
 
 Status WriteStringToFile(Env* env, const Slice& data, const std::string& fname,
-                         bool should_sync) {
+                         bool should_sync, const IOOptions* io_options) {
   const auto& fs = env->GetFileSystem();
-  return WriteStringToFile(fs.get(), data, fname, should_sync);
+  return WriteStringToFile(fs.get(), data, fname, should_sync,
+                           io_options ? *io_options : IOOptions());
 }
 
 Status ReadFileToString(Env* env, const std::string& fname, std::string* data) {

package/deps/rocksdb/rocksdb/env/env_basic_test.cc

@@ -57,10 +57,10 @@ static Env* GetTestEnv() {
   static std::shared_ptr<Env> env_guard;
   static Env* custom_env = nullptr;
   if (custom_env == nullptr) {
-    const char* uri = getenv("TEST_ENV_URI");
-    if (uri != nullptr) {
-      EXPECT_OK(Env::CreateFromUri(ConfigOptions(), uri, "", &custom_env,
-                                   &env_guard));
+    const char* env_uri = getenv("TEST_ENV_URI");
+    if (env_uri != nullptr) {
+      EXPECT_OK(Env::CreateFromUri(ConfigOptions(), env_uri, /*fs_uri=*/"",
+                                   &custom_env, &env_guard));
     }
   }
   EXPECT_NE(custom_env, nullptr);
@@ -71,10 +71,10 @@ static Env* GetTestFS() {
   static std::shared_ptr<Env> fs_env_guard;
   static Env* fs_env = nullptr;
   if (fs_env == nullptr) {
-    const char* uri = getenv("TEST_FS_URI");
-    if (uri != nullptr) {
-      EXPECT_OK(
-          Env::CreateFromUri(ConfigOptions(), uri, "", &fs_env, &fs_env_guard));
+    const char* fs_uri = getenv("TEST_FS_URI");
+    if (fs_uri != nullptr) {
+      EXPECT_OK(Env::CreateFromUri(ConfigOptions(), /*env_uri=*/"", fs_uri,
+                                   &fs_env, &fs_env_guard));
     }
   }
   EXPECT_NE(fs_env, nullptr);
@@ -342,7 +342,7 @@ TEST_P(EnvMoreTestWithParam, GetChildren) {
   ASSERT_OK(env_->GetChildrenFileAttributes(test_dir_, &childAttr));
   ASSERT_EQ(3U, children.size());
   ASSERT_EQ(3U, childAttr.size());
-  for (auto each : children) {
+  for (const auto& each : children) {
     env_->DeleteDir(test_dir_ + "/" + each).PermitUncheckedError();
   }  // necessary for default POSIX env
 

package/deps/rocksdb/rocksdb/env/env_chroot.cc

@@ -7,10 +7,11 @@
 
 #include "env/env_chroot.h"
 
-#include <errno.h>   // errno
-#include <stdlib.h>  // realpath, free
 #include <unistd.h>  // geteuid
 
+#include <cerrno>   // errno
+#include <cstdlib>  // realpath, free
+
 #include "env/composite_env_wrapper.h"
 #include "env/fs_remap.h"
 #include "rocksdb/utilities/options_type.h"

package/deps/rocksdb/rocksdb/env/env_encryption.cc

@@ -117,7 +117,7 @@ IOStatus EncryptedRandomAccessFile::Prefetch(uint64_t offset, size_t n,
 
 size_t EncryptedRandomAccessFile::GetUniqueId(char* id, size_t max_size) const {
   return file_->GetUniqueId(id, max_size);
-};
+}
 
 void EncryptedRandomAccessFile::Hint(AccessPattern pattern) {
   file_->Hint(pattern);
@@ -827,7 +827,7 @@ Status BlockAccessCipherStream::Encrypt(uint64_t fileOffset, char* data,
   AllocateScratch(scratch);
 
   // Encrypt individual blocks.
-  while (1) {
+  while (true) {
     char* block = data;
     size_t n = std::min(dataSize, blockSize - blockOffset);
     if (n != blockSize) {
@@ -871,7 +871,7 @@ Status BlockAccessCipherStream::Decrypt(uint64_t fileOffset, char* data,
   AllocateScratch(scratch);
 
   // Decrypt individual blocks.
-  while (1) {
+  while (true) {
     char* block = data;
     size_t n = std::min(dataSize, blockSize - blockOffset);
     if (n != blockSize) {

package/deps/rocksdb/rocksdb/env/env_encryption_ctr.h

@@ -24,8 +24,8 @@ class CTRCipherStream final : public BlockAccessCipherStream {
  public:
   CTRCipherStream(const std::shared_ptr<BlockCipher>& c, const char* iv,
                   uint64_t initialCounter)
-      : cipher_(c), iv_(iv, c->BlockSize()), initialCounter_(initialCounter){};
-  virtual ~CTRCipherStream(){};
+      : cipher_(c), iv_(iv, c->BlockSize()), initialCounter_(initialCounter){}
+  virtual ~CTRCipherStream(){}
 
   size_t BlockSize() override { return cipher_->BlockSize(); }
 

package/deps/rocksdb/rocksdb/env/env_posix.cc

@@ -14,19 +14,21 @@
 #ifndef ROCKSDB_NO_DYNAMIC_EXTENSION
 #include <dlfcn.h>
 #endif
-#include <errno.h>
 #include <fcntl.h>
 
+#include <cerrno>
+
 #if defined(ROCKSDB_IOURING_PRESENT)
 #include <liburing.h>
 #endif
 #include <pthread.h>
-#include <signal.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
 #include <sys/mman.h>
 #include <sys/stat.h>
+
+#include <csignal>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
 #if defined(OS_LINUX) || defined(OS_SOLARIS) || defined(OS_ANDROID)
 #include <sys/statfs.h>
 #endif
@@ -36,10 +38,10 @@
 #if defined(ROCKSDB_IOURING_PRESENT)
 #include <sys/uio.h>
 #endif
-#include <time.h>
 #include <unistd.h>
 
 #include <algorithm>
+#include <ctime>
 // Get nano time includes
 #if defined(OS_LINUX) || defined(OS_FREEBSD) || defined(OS_GNU_KFREEBSD)
 #elif defined(__MACH__)
@@ -84,9 +86,9 @@
 namespace ROCKSDB_NAMESPACE {
 #if defined(OS_WIN)
 static const std::string kSharedLibExt = ".dll";
-static const char kPathSeparator = ';';
+[[maybe_unused]] static const char kPathSeparator = ';';
 #else
-static const char kPathSeparator = ':';
+[[maybe_unused]] static const char kPathSeparator = ':';
 #if defined(OS_MACOSX)
 static const std::string kSharedLibExt = ".dylib";
 #else
@@ -199,7 +201,7 @@ class PosixClock : public SystemClock {
     std::string dummy;
     dummy.reserve(maxsize);
     dummy.resize(maxsize);
-    char* p = &dummy[0];
+    char* p = dummy.data();
     port::LocalTimeR(&seconds, &t);
     snprintf(p, maxsize, "%04d/%02d/%02d-%02d:%02d:%02d ", t.tm_year + 1900,
              t.tm_mon + 1, t.tm_mday, t.tm_hour, t.tm_min, t.tm_sec);
@@ -463,7 +465,7 @@ struct StartThreadState {
 };
 
 static void* StartThreadWrapper(void* arg) {
-  StartThreadState* state = reinterpret_cast<StartThreadState*>(arg);
+  StartThreadState* state = static_cast<StartThreadState*>(arg);
   state->user_function(state->arg);
   delete state;
   return nullptr;

package/deps/rocksdb/rocksdb/env/env_test.cc

@@ -26,13 +26,14 @@
 #ifdef OS_LINUX
 #include <fcntl.h>
 #include <linux/fs.h>
-#include <stdlib.h>
 #include <sys/stat.h>
 #include <unistd.h>
+
+#include <cstdlib>
 #endif
 
 #ifdef ROCKSDB_FALLOCATE_PRESENT
-#include <errno.h>
+#include <cerrno>
 #endif
 
 #include "db/db_impl/db_impl.h"
@@ -238,13 +239,11 @@ TEST_F(EnvPosixTest, LowerThreadPoolCpuPriority) {
   std::atomic<CpuPriority> from_priority(CpuPriority::kNormal);
   std::atomic<CpuPriority> to_priority(CpuPriority::kNormal);
   ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
-      "ThreadPoolImpl::BGThread::BeforeSetCpuPriority", [&](void* pri) {
-        from_priority.store(*reinterpret_cast<CpuPriority*>(pri));
-      });
+      "ThreadPoolImpl::BGThread::BeforeSetCpuPriority",
+      [&](void* pri) { from_priority.store(*static_cast<CpuPriority*>(pri)); });
   ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
-      "ThreadPoolImpl::BGThread::AfterSetCpuPriority", [&](void* pri) {
-        to_priority.store(*reinterpret_cast<CpuPriority*>(pri));
-      });
+      "ThreadPoolImpl::BGThread::AfterSetCpuPriority",
+      [&](void* pri) { to_priority.store(*static_cast<CpuPriority*>(pri)); });
   ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->EnableProcessing();
 
   env_->SetBackgroundThreads(1, Env::BOTTOM);
@@ -446,7 +445,7 @@ TEST_P(EnvPosixTestWithParam, RunMany) {
     CB(std::atomic<int>* p, int i) : last_id_ptr(p), id(i) {}
 
     static void Run(void* v) {
-      CB* cb = reinterpret_cast<CB*>(v);
+      CB* cb = static_cast<CB*>(v);
       int cur = cb->last_id_ptr->load();
       ASSERT_EQ(cb->id - 1, cur);
       cb->last_id_ptr->store(cb->id);
@@ -483,7 +482,7 @@ struct State {
 };
 
 static void ThreadBody(void* arg) {
-  State* s = reinterpret_cast<State*>(arg);
+  State* s = static_cast<State*>(arg);
   s->mu.Lock();
   s->val += 1;
   s->num_running -= 1;
@@ -530,7 +529,7 @@ TEST_P(EnvPosixTestWithParam, TwoPools) {
           should_start_(_should_start) {}
 
     static void Run(void* v) {
-      CB* cb = reinterpret_cast<CB*>(v);
+      CB* cb = static_cast<CB*>(v);
       cb->Run();
     }
 
@@ -2609,7 +2608,7 @@ TEST_F(EnvTest, IsDirectory) {
                                          FileOptions(),
                                          SystemClock::Default().get()));
     constexpr char buf[] = "test";
-    s = fwriter->Append(buf);
+    s = fwriter->Append(IOOptions(), buf);
     ASSERT_OK(s);
   }
   ASSERT_OK(Env::Default()->IsDirectory(test_file_path, &is_dir));
@@ -2906,6 +2905,13 @@ TEST_F(CreateEnvTest, CreateEncryptedFileSystem) {
 
   std::string base_opts =
       std::string("provider=1://test; id=") + EncryptedFileSystem::kClassName();
+  // Rewrite the default FileSystem URI if the "TEST_FS_URI" environment
+  // variable is set. This is useful to test customer encryption plugins.
+  const char* uri = getenv("TEST_FS_URI");
+  if (uri != nullptr) {
+    base_opts = uri;
+  }
+
   // The EncryptedFileSystem requires a "provider" option.
   ASSERT_NOK(FileSystem::CreateFromString(
       config_options_, EncryptedFileSystem::kClassName(), &fs));
@@ -2948,7 +2954,7 @@ struct NoDuplicateMiniStressTest {
 
   NoDuplicateMiniStressTest() { env = Env::Default(); }
 
-  virtual ~NoDuplicateMiniStressTest() {}
+  virtual ~NoDuplicateMiniStressTest() = default;
 
   void Run() {
     std::array<std::thread, kThreads> threads;
@@ -3441,7 +3447,7 @@ TEST_F(CreateEnvTest, CreateCompositeEnv) {
 class ReadAsyncFS;
 
 struct MockIOHandle {
-  std::function<void(const FSReadRequest&, void*)> cb;
+  std::function<void(FSReadRequest&, void*)> cb;
   void* cb_arg;
   bool create_io_error;
 };
@@ -3456,7 +3462,7 @@ class ReadAsyncRandomAccessFile : public FSRandomAccessFileOwnerWrapper {
       : FSRandomAccessFileOwnerWrapper(std::move(file)), fs_(fs) {}
 
   IOStatus ReadAsync(FSReadRequest& req, const IOOptions& opts,
-                     std::function<void(const FSReadRequest&, void*)> cb,
+                     std::function<void(FSReadRequest&, void*)> cb,
                      void* cb_arg, void** io_handle, IOHandleDeleter* del_fn,
                      IODebugContext* dbg) override;
 
@@ -3508,7 +3514,7 @@ class ReadAsyncFS : public FileSystemWrapper {
 
 IOStatus ReadAsyncRandomAccessFile::ReadAsync(
     FSReadRequest& req, const IOOptions& opts,
-    std::function<void(const FSReadRequest&, void*)> cb, void* cb_arg,
+    std::function<void(FSReadRequest&, void*)> cb, void* cb_arg,
     void** io_handle, IOHandleDeleter* del_fn, IODebugContext* dbg) {
   IOHandleDeleter deletefn = [](void* args) -> void {
     delete (static_cast<MockIOHandle*>(args));
@@ -3596,8 +3602,8 @@ TEST_F(TestAsyncRead, ReadAsync) {
     }
 
     // callback function passed to async read.
-    std::function<void(const FSReadRequest&, void*)> callback =
-        [&](const FSReadRequest& req, void* cb_arg) {
+    std::function<void(FSReadRequest&, void*)> callback =
+        [&](FSReadRequest& req, void* cb_arg) {
           assert(cb_arg != nullptr);
           size_t i = *(reinterpret_cast<size_t*>(cb_arg));
           reqs[i].offset = req.offset;

package/deps/rocksdb/rocksdb/env/file_system.cc

@@ -22,9 +22,9 @@
 
 namespace ROCKSDB_NAMESPACE {
 
-FileSystem::FileSystem() {}
+FileSystem::FileSystem() = default;
 
-FileSystem::~FileSystem() {}
+FileSystem::~FileSystem() = default;
 
 static int RegisterBuiltinFileSystems(ObjectLibrary& library,
                                       const std::string& /*arg*/) {
@@ -180,19 +180,20 @@ FileOptions FileSystem::OptimizeForBlobFileRead(
 }
 
 IOStatus WriteStringToFile(FileSystem* fs, const Slice& data,
-                           const std::string& fname, bool should_sync) {
+                           const std::string& fname, bool should_sync,
+                           const IOOptions& io_options) {
   std::unique_ptr<FSWritableFile> file;
   EnvOptions soptions;
   IOStatus s = fs->NewWritableFile(fname, soptions, &file, nullptr);
   if (!s.ok()) {
     return s;
   }
-  s = file->Append(data, IOOptions(), nullptr);
+  s = file->Append(data, io_options, nullptr);
   if (s.ok() && should_sync) {
-    s = file->Sync(IOOptions(), nullptr);
+    s = file->Sync(io_options, nullptr);
   }
   if (!s.ok()) {
-    fs->DeleteFile(fname, IOOptions(), nullptr);
+    fs->DeleteFile(fname, io_options, nullptr);
   }
   return s;
 }

package/deps/rocksdb/rocksdb/env/file_system_tracer.cc

@@ -340,7 +340,7 @@ IOStatus FSRandomAccessFileTracingWrapper::InvalidateCache(size_t offset,
 
 IOStatus FSRandomAccessFileTracingWrapper::ReadAsync(
     FSReadRequest& req, const IOOptions& opts,
-    std::function<void(const FSReadRequest&, void*)> cb, void* cb_arg,
+    std::function<void(FSReadRequest&, void*)> cb, void* cb_arg,
     void** io_handle, IOHandleDeleter* del_fn, IODebugContext* dbg) {
   // Create a callback and populate info.
   auto read_async_callback =
@@ -361,8 +361,8 @@ IOStatus FSRandomAccessFileTracingWrapper::ReadAsync(
   return s;
 }
 
-void FSRandomAccessFileTracingWrapper::ReadAsyncCallback(
-    const FSReadRequest& req, void* cb_arg) {
+void FSRandomAccessFileTracingWrapper::ReadAsyncCallback(FSReadRequest& req,
+                                                         void* cb_arg) {
   ReadAsyncCallbackInfo* read_async_cb_info =
       static_cast<ReadAsyncCallbackInfo*>(cb_arg);
   assert(read_async_cb_info);

package/deps/rocksdb/rocksdb/env/file_system_tracer.h

@@ -229,11 +229,11 @@ class FSRandomAccessFileTracingWrapper : public FSRandomAccessFileOwnerWrapper {
   IOStatus InvalidateCache(size_t offset, size_t length) override;
 
   IOStatus ReadAsync(FSReadRequest& req, const IOOptions& opts,
-                     std::function<void(const FSReadRequest&, void*)> cb,
+                     std::function<void(FSReadRequest&, void*)> cb,
                      void* cb_arg, void** io_handle, IOHandleDeleter* del_fn,
                      IODebugContext* dbg) override;
 
-  void ReadAsyncCallback(const FSReadRequest& req, void* cb_arg);
+  void ReadAsyncCallback(FSReadRequest& req, void* cb_arg);
 
  private:
   std::shared_ptr<IOTracer> io_tracer_;
@@ -243,7 +243,7 @@ class FSRandomAccessFileTracingWrapper : public FSRandomAccessFileOwnerWrapper {
 
   struct ReadAsyncCallbackInfo {
     uint64_t start_time_;
-    std::function<void(const FSReadRequest&, void*)> cb_;
+    std::function<void(FSReadRequest&, void*)> cb_;
     void* cb_arg_;
     std::string file_op_;
   };