@nxtedition/rocksdb 11.0.3 → 11.0.5

package/binding.cc

@@ -37,7 +37,7 @@ class NullLogger : public rocksdb::Logger {
 };
 
 struct Database;
-struct Iterator;
+class Iterator;
 
 struct ColumnFamily {
   rocksdb::ColumnFamilyHandle* handle;
@@ -285,10 +285,7 @@ struct BaseIterator : public Closable {
                const int limit,
                const bool fillCache,
                bool tailing = false)
-      : database_(database),
-        column_(column),
-        reverse_(reverse),
-        limit_(limit) {
+      : database_(database), column_(column), reverse_(reverse), limit_(limit) {
     if (lte) {
       upper_bound_ = rocksdb::PinnableSlice();
       *upper_bound_->GetSelf() = std::move(*lte) + '\0';
@@ -310,12 +307,15 @@ struct BaseIterator : public Closable {
     }
 
     rocksdb::ReadOptions readOptions;
+
     if (upper_bound_) {
       readOptions.iterate_upper_bound = &*upper_bound_;
     }
+
     if (lower_bound_) {
       readOptions.iterate_lower_bound = &*lower_bound_;
     }
+
     readOptions.fill_cache = fillCache;
     readOptions.async_io = true;
     readOptions.adaptive_readahead = true;
@@ -332,9 +332,15 @@ struct BaseIterator : public Closable {
     database_->Attach(this);
   }
 
-  virtual ~BaseIterator() { assert(!iterator_); }
+  virtual ~BaseIterator() {
+    if (iterator_) {
+      database_->Detach(this);
+    }
+  }
 
   virtual void Seek(const rocksdb::Slice& target) {
+    assert(iterator_);
+
     if ((upper_bound_ && target.compare(*upper_bound_) >= 0) || (lower_bound_ && target.compare(*lower_bound_) < 0)) {
       // TODO (fix): Why is this required? Seek should handle it?
       // https://github.com/facebook/rocksdb/issues/9904
@@ -350,8 +356,10 @@ struct BaseIterator : public Closable {
   }
 
   virtual rocksdb::Status Close() override {
-    iterator_.reset();
-    database_->Detach(this);
+    if (iterator_) {
+      iterator_.reset();
+      database_->Detach(this);
+    }
     return rocksdb::Status::OK();
   }
 
@@ -393,7 +401,6 @@ struct BaseIterator : public Closable {
   rocksdb::ColumnFamilyHandle* column_;
 
  private:
-
   int count_ = 0;
   std::optional<rocksdb::PinnableSlice> lower_bound_;
   std::optional<rocksdb::PinnableSlice> upper_bound_;
@@ -402,7 +409,15 @@ struct BaseIterator : public Closable {
   const int limit_;
 };
 
-struct Iterator final : public BaseIterator {
+class Iterator final : public BaseIterator {
+  const bool keys_;
+  const bool values_;
+  const size_t highWaterMarkBytes_;
+  bool first_ = true;
+  const Encoding keyEncoding_;
+  const Encoding valueEncoding_;
+
+ public:
   Iterator(Database* database,
            rocksdb::ColumnFamilyHandle* column,
            const bool reverse,
@@ -430,12 +445,115 @@ struct Iterator final : public BaseIterator {
     return BaseIterator::Seek(target);
   }
 
-  const bool keys_;
-  const bool values_;
-  const size_t highWaterMarkBytes_;
-  bool first_ = true;
-  const Encoding keyEncoding_;
-  const Encoding valueEncoding_;
+  static std::unique_ptr<Iterator> create(napi_env env, napi_value db, napi_value options) {
+    Database* database;
+    NAPI_STATUS_THROWS(napi_get_value_external(env, db, reinterpret_cast<void**>(&database)));
+
+    bool reverse = false;
+    NAPI_STATUS_THROWS(GetProperty(env, options, "reverse", reverse));
+
+    bool keys = true;
+    NAPI_STATUS_THROWS(GetProperty(env, options, "keys", keys));
+
+    bool values = true;
+    NAPI_STATUS_THROWS(GetProperty(env, options, "values", values));
+
+    bool tailing = false;
+    NAPI_STATUS_THROWS(GetProperty(env, options, "tailing", tailing));
+
+    bool fillCache = false;
+    NAPI_STATUS_THROWS(GetProperty(env, options, "fillCache", fillCache));
+
+    int32_t limit = -1;
+    NAPI_STATUS_THROWS(GetProperty(env, options, "limit", limit));
+
+    int32_t highWaterMarkBytes = 64 * 1024;
+    NAPI_STATUS_THROWS(GetProperty(env, options, "highWaterMarkBytes", highWaterMarkBytes));
+
+    std::optional<std::string> lt;
+    NAPI_STATUS_THROWS(GetProperty(env, options, "lt", lt));
+
+    std::optional<std::string> lte;
+    NAPI_STATUS_THROWS(GetProperty(env, options, "lte", lte));
+
+    std::optional<std::string> gt;
+    NAPI_STATUS_THROWS(GetProperty(env, options, "gt", gt));
+
+    std::optional<std::string> gte;
+    NAPI_STATUS_THROWS(GetProperty(env, options, "gte", gte));
+
+    rocksdb::ColumnFamilyHandle* column = database->db->DefaultColumnFamily();
+    NAPI_STATUS_THROWS(GetProperty(env, options, "column", column));
+
+    Encoding keyEncoding;
+    NAPI_STATUS_THROWS(GetProperty(env, options, "keyEncoding", keyEncoding));
+
+    Encoding valueEncoding;
+    NAPI_STATUS_THROWS(GetProperty(env, options, "valueEncoding", valueEncoding));
+
+    return std::make_unique<Iterator>(database, column, reverse, keys, values, limit, lt, lte, gt, gte, fillCache,
+                                      highWaterMarkBytes, tailing, keyEncoding, valueEncoding);
+  }
+
+  napi_value nextv(napi_env env, uint32_t count) {
+    napi_value finished;
+    NAPI_STATUS_THROWS(napi_get_boolean(env, false, &finished));
+
+    napi_value rows;
+    NAPI_STATUS_THROWS(napi_create_array(env, &rows));
+
+    size_t idx = 0;
+    size_t bytesRead = 0;
+    while (true) {
+      if (!first_) {
+        Next();
+      } else {
+        first_ = false;
+      }
+
+      if (!Valid() || !Increment()) {
+        ROCKS_STATUS_THROWS_NAPI(Status());
+        NAPI_STATUS_THROWS(napi_get_boolean(env, true, &finished));
+        break;
+      }
+
+      napi_value key;
+      napi_value val;
+
+      if (keys_ && values_) {
+        const auto k = CurrentKey();
+        const auto v = CurrentValue();
+        NAPI_STATUS_THROWS(Convert(env, &k, keyEncoding_, key));
+        NAPI_STATUS_THROWS(Convert(env, &v, valueEncoding_, val));
+        bytesRead += k.size() + v.size();
+      } else if (keys_) {
+        const auto k = CurrentKey();
+        NAPI_STATUS_THROWS(Convert(env, &k, keyEncoding_, key));
+        NAPI_STATUS_THROWS(napi_get_undefined(env, &val));
+        bytesRead += k.size();
+      } else if (values_) {
+        const auto v = CurrentValue();
+        NAPI_STATUS_THROWS(napi_get_undefined(env, &key));
+        NAPI_STATUS_THROWS(Convert(env, &v, valueEncoding_, val));
+        bytesRead += v.size();
+      } else {
+        assert(false);
+      }
+
+      NAPI_STATUS_THROWS(napi_set_element(env, rows, idx++, key));
+      NAPI_STATUS_THROWS(napi_set_element(env, rows, idx++, val));
+
+      if (bytesRead > highWaterMarkBytes_ || idx / 2 >= count) {
+        break;
+      }
+    }
+
+    napi_value ret;
+    NAPI_STATUS_THROWS(napi_create_object(env, &ret));
+    NAPI_STATUS_THROWS(napi_set_named_property(env, ret, "rows", rows));
+    NAPI_STATUS_THROWS(napi_set_named_property(env, ret, "finished", finished));
+    return ret;
+  }
 };
 
 /**
@@ -525,6 +643,13 @@ NAPI_METHOD(db_get_location) {
   return result;
 }
 
+
+NAPI_METHOD(db_query) {
+  NAPI_ARGV(2);
+
+  return Iterator::create(env, argv[0], argv[1])->nextv(env, std::numeric_limits<uint32_t>::max());
+}
+
 template <typename T, typename U>
 napi_status InitOptions(napi_env env, T& columnOptions, const U& options) {
   rocksdb::ConfigOptions configOptions;
@@ -673,6 +798,7 @@ napi_status InitOptions(napi_env env, T& columnOptions, const U& options) {
 
   tableOptions.format_version = 5;
   tableOptions.checksum = rocksdb::kXXH3;
+  tableOptions.decouple_partitioned_filters = true;
 
   tableOptions.optimize_filters_for_memory = true;
   NAPI_STATUS_RETURN(GetProperty(env, options, "optimizeFiltersForMemory", tableOptions.optimize_filters_for_memory));
@@ -919,9 +1045,9 @@ NAPI_METHOD(db_get_many) {
   for (auto n = 0; n < count; n++) {
     napi_value row;
     if (statuses[n].IsNotFound()) {
-      NAPI_STATUS_THROWS(napi_get_null(env, &row));
-    } else if (statuses[n].IsAborted()) {
       NAPI_STATUS_THROWS(napi_get_undefined(env, &row));
+    } else if (statuses[n].IsAborted()) {
+      NAPI_STATUS_THROWS(napi_get_null(env, &row));
     } else {
       ROCKS_STATUS_THROWS_NAPI(statuses[n]);
       NAPI_STATUS_THROWS(Convert(env, &values[n], valueEncoding, row));
@@ -1070,56 +1196,7 @@ NAPI_METHOD(db_get_latest_sequence) {
 NAPI_METHOD(iterator_init) {
   NAPI_ARGV(2);
 
-  Database* database;
-  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&database)));
-
-  const auto options = argv[1];
-
-  bool reverse = false;
-  NAPI_STATUS_THROWS(GetProperty(env, options, "reverse", reverse));
-
-  bool keys = true;
-  NAPI_STATUS_THROWS(GetProperty(env, options, "keys", keys));
-
-  bool values = true;
-  NAPI_STATUS_THROWS(GetProperty(env, options, "values", values));
-
-  bool tailing = false;
-  NAPI_STATUS_THROWS(GetProperty(env, options, "tailing", tailing));
-
-  bool fillCache = false;
-  NAPI_STATUS_THROWS(GetProperty(env, options, "fillCache", fillCache));
-
-  int32_t limit = -1;
-  NAPI_STATUS_THROWS(GetProperty(env, options, "limit", limit));
-
-  int32_t highWaterMarkBytes = 64 * 1024;
-  NAPI_STATUS_THROWS(GetProperty(env, options, "highWaterMarkBytes", highWaterMarkBytes));
-
-  std::optional<std::string> lt;
-  NAPI_STATUS_THROWS(GetProperty(env, options, "lt", lt));
-
-  std::optional<std::string> lte;
-  NAPI_STATUS_THROWS(GetProperty(env, options, "lte", lte));
-
-  std::optional<std::string> gt;
-  NAPI_STATUS_THROWS(GetProperty(env, options, "gt", gt));
-
-  std::optional<std::string> gte;
-  NAPI_STATUS_THROWS(GetProperty(env, options, "gte", gte));
-
-  rocksdb::ColumnFamilyHandle* column = database->db->DefaultColumnFamily();
-  NAPI_STATUS_THROWS(GetProperty(env, options, "column", column));
-
-  Encoding keyEncoding;
-  NAPI_STATUS_THROWS(GetProperty(env, options, "keyEncoding", keyEncoding));
-
-  Encoding valueEncoding;
-  NAPI_STATUS_THROWS(GetProperty(env, options, "valueEncoding", valueEncoding));
-
-  auto iterator = std::unique_ptr<Iterator>(new Iterator(database, column, reverse, keys, values, limit, lt, lte, gt,
-                                                         gte, fillCache, highWaterMarkBytes,
-                                                         tailing, keyEncoding, valueEncoding));
+  auto iterator = Iterator::create(env, argv[0], argv[1]);
 
   napi_value result;
   NAPI_STATUS_THROWS(napi_create_external(env, iterator.get(), Finalize<Iterator>, iterator.get(), &result));
@@ -1162,63 +1239,7 @@ NAPI_METHOD(iterator_nextv) {
   uint32_t count;
   NAPI_STATUS_THROWS(napi_get_value_uint32(env, argv[1], &count));
 
-  napi_value finished;
-  NAPI_STATUS_THROWS(napi_get_boolean(env, false, &finished));
-
-  napi_value rows;
-  NAPI_STATUS_THROWS(napi_create_array(env, &rows));
-
-  size_t idx = 0;
-  size_t bytesRead = 0;
-  while (true) {
-    if (!iterator->first_) {
-      iterator->Next();
-    } else {
-      iterator->first_ = false;
-    }
-
-    if (!iterator->Valid() || !iterator->Increment()) {
-      ROCKS_STATUS_THROWS_NAPI(iterator->Status());
-      NAPI_STATUS_THROWS(napi_get_boolean(env, true, &finished));
-      break;
-    }
-
-    napi_value key;
-    napi_value val;
-
-    if (iterator->keys_ && iterator->values_) {
-      const auto k = iterator->CurrentKey();
-      const auto v = iterator->CurrentValue();
-      NAPI_STATUS_THROWS(Convert(env, &k, iterator->keyEncoding_, key));
-      NAPI_STATUS_THROWS(Convert(env, &v, iterator->valueEncoding_, val));
-      bytesRead += k.size() + v.size();
-    } else if (iterator->keys_) {
-      const auto k = iterator->CurrentKey();
-      NAPI_STATUS_THROWS(Convert(env, &k, iterator->keyEncoding_, key));
-      NAPI_STATUS_THROWS(napi_get_undefined(env, &val));
-      bytesRead += k.size();
-    } else if (iterator->values_) {
-      const auto v = iterator->CurrentValue();
-      NAPI_STATUS_THROWS(napi_get_undefined(env, &key));
-      NAPI_STATUS_THROWS(Convert(env, &v, iterator->valueEncoding_, val));
-      bytesRead += v.size();
-    } else {
-      assert(false);
-    }
-
-    NAPI_STATUS_THROWS(napi_set_element(env, rows, idx++, key));
-    NAPI_STATUS_THROWS(napi_set_element(env, rows, idx++, val));
-
-    if (bytesRead > iterator->highWaterMarkBytes_ || idx / 2 >= count) {
-      break;
-    }
-  }
-
-  napi_value ret;
-  NAPI_STATUS_THROWS(napi_create_object(env, &ret));
-  NAPI_STATUS_THROWS(napi_set_named_property(env, ret, "rows", rows));
-  NAPI_STATUS_THROWS(napi_set_named_property(env, ret, "finished", finished));
-  return ret;
+  return iterator->nextv(env, count);
 }
 
 NAPI_METHOD(batch_init) {
@@ -1403,6 +1424,7 @@ NAPI_INIT() {
   NAPI_EXPORT_FUNCTION(db_clear);
   NAPI_EXPORT_FUNCTION(db_get_property);
   NAPI_EXPORT_FUNCTION(db_get_latest_sequence);
+  NAPI_EXPORT_FUNCTION(db_query);
 
   NAPI_EXPORT_FUNCTION(iterator_init);
   NAPI_EXPORT_FUNCTION(iterator_seek);

package/deps/rocksdb/rocksdb/db/column_family_test.cc

@@ -3067,12 +3067,20 @@ TEST_P(ColumnFamilyTest, CompactionSpeedupForMarkedFiles) {
   WaitForCompaction();
   AssertFilesPerLevel("0,1", 0 /* cf */);
 
+  // We should calculate the limit by obtaining the number of env background
+  // threads, because the current test case will share the same env
+  // with another case that may have already increased the number of
+  // background threads which is larger than kParallelismLimit
+  const auto limit = env_->GetBackgroundThreads(Env::Priority::LOW);
+
   // Block the compaction thread pool so marked files accumulate in L0.
-  test::SleepingBackgroundTask sleeping_tasks[kParallelismLimit];
-  for (int i = 0; i < kParallelismLimit; i++) {
+  std::vector<std::shared_ptr<test::SleepingBackgroundTask>> sleeping_tasks;
+  for (int i = 0; i < limit; i++) {
+    sleeping_tasks.emplace_back(
+        std::make_shared<test::SleepingBackgroundTask>());
     env_->Schedule(&test::SleepingBackgroundTask::DoSleepTask,
-                   &sleeping_tasks[i], Env::Priority::LOW);
-    sleeping_tasks[i].WaitUntilSleeping();
+                   sleeping_tasks[i].get(), Env::Priority::LOW);
+    sleeping_tasks[i]->WaitUntilSleeping();
   }
 
   // Zero marked upper-level files. No speedup.
@@ -3091,9 +3099,9 @@ TEST_P(ColumnFamilyTest, CompactionSpeedupForMarkedFiles) {
   ASSERT_EQ(kParallelismLimit, dbfull()->TEST_BGCompactionsAllowed());
   AssertFilesPerLevel("2,1", 0 /* cf */);
 
-  for (int i = 0; i < kParallelismLimit; i++) {
-    sleeping_tasks[i].WakeUp();
-    sleeping_tasks[i].WaitUntilDone();
+  for (int i = 0; i < limit; i++) {
+    sleeping_tasks[i]->WakeUp();
+    sleeping_tasks[i]->WaitUntilDone();
   }
 }
 

package/deps/rocksdb/rocksdb/db/compaction/compaction_job_test.cc

@@ -552,7 +552,8 @@ class CompactionJobTestBase : public testing::Test {
         /*db_id=*/"", /*db_session_id=*/"", /*daily_offpeak_time_utc=*/"",
         /*error_handler=*/nullptr, /*read_only=*/false));
     compaction_job_stats_.Reset();
-    ASSERT_OK(SetIdentityFile(WriteOptions(), env_, dbname_));
+    ASSERT_OK(
+        SetIdentityFile(WriteOptions(), env_, dbname_, Temperature::kUnknown));
 
     VersionEdit new_db;
     new_db.SetLogNumber(0);
@@ -575,7 +576,8 @@ class CompactionJobTestBase : public testing::Test {
     }
     ASSERT_OK(s);
     // Make "CURRENT" file that points to the new manifest file.
-    s = SetCurrentFile(WriteOptions(), fs_.get(), dbname_, 1, nullptr);
+    s = SetCurrentFile(WriteOptions(), fs_.get(), dbname_, 1,
+                       Temperature::kUnknown, nullptr);
 
     ASSERT_OK(s);
 

package/deps/rocksdb/rocksdb/db/compaction/compaction_picker_level.cc

@@ -925,11 +925,15 @@ bool LevelCompactionBuilder::PickSizeBasedIntraL0Compaction() {
   }
   uint64_t l0_size = 0;
   for (const auto& file : l0_files) {
-    l0_size += file->fd.GetFileSize();
+    assert(file->compensated_file_size >= file->fd.GetFileSize());
+    // Compact down L0s with more deletions.
+    l0_size += file->compensated_file_size;
   }
-  const uint64_t min_lbase_size =
-      l0_size * static_cast<uint64_t>(std::max(
-                    10.0, mutable_cf_options_.max_bytes_for_level_multiplier));
+
+  // Avoid L0->Lbase compactions that are inefficient for write-amp.
+  const double kMultiplier =
+      std::max(10.0, mutable_cf_options_.max_bytes_for_level_multiplier) * 2;
+  const uint64_t min_lbase_size = MultiplyCheckOverflow(l0_size, kMultiplier);
   assert(min_lbase_size >= l0_size);
   const std::vector<FileMetaData*>& lbase_files =
       vstorage_->LevelFiles(/*level=*/base_level);

package/deps/rocksdb/rocksdb/db/compaction/compaction_picker_test.cc

@@ -214,7 +214,10 @@ class CompactionPickerTest : public CompactionPickerTestBase {
   explicit CompactionPickerTest()
       : CompactionPickerTestBase(BytewiseComparator()) {}
 
-  ~CompactionPickerTest() override = default;
+  ~CompactionPickerTest() override {
+    SyncPoint::GetInstance()->ClearAllCallBacks();
+    SyncPoint::GetInstance()->DisableProcessing();
+  }
 };
 
 class CompactionPickerU64TsTest : public CompactionPickerTestBase {
@@ -4284,27 +4287,28 @@ TEST_F(CompactionPickerTest, IntraL0WhenL0IsSmall) {
     SCOPED_TRACE("lbase_size_multiplier=" +
                  std::to_string(lbase_size_multiplier));
     NewVersionStorage(6, kCompactionStyleLevel);
-    // When L0 size is <= Lbase size / max_bytes_for_level_multiplier,
+    // When L0 size is <= Lbase size / max_bytes_for_level_multiplier / 2,
     // intra-L0 compaction is picked. Otherwise, L0->L1
     // compaction is picked.
+    // compensated_file_size will be used to compute total l0 size.
     Add(/*level=*/0, /*file_number=*/1U, /*smallest=*/"100",
-        /*largest=*/"200", /*file_size=*/1000, /*path_id=*/0,
+        /*largest=*/"200", /*file_size=*/10, /*path_id=*/0,
         /*smallest_seq=*/10, /*largest_seq=*/11,
         /*compensated_file_size=*/1000);
     Add(/*level=*/0, /*file_number=*/2U, /*smallest=*/"100",
-        /*largest=*/"100", /*file_size=*/1000, /*path_id=*/0,
+        /*largest=*/"100", /*file_size=*/10, /*path_id=*/0,
         /*smallest_seq=*/20, /*largest_seq=*/21,
         /*compensated_file_size=*/1000);
     Add(/*level=*/0, /*file_number=*/3U, /*smallest=*/"100",
-        /*largest=*/"200", /*file_size=*/1000, /*path_id=*/0,
+        /*largest=*/"200", /*file_size=*/10, /*path_id=*/0,
         /*smallest_seq=*/30, /*largest_seq=*/31,
         /*compensated_file_size=*/1000);
     Add(/*level=*/0, /*file_number=*/4U, /*smallest=*/"100",
-        /*largest=*/"200", /*file_size=*/1000, /*path_id=*/0,
+        /*largest=*/"200", /*file_size=*/10, /*path_id=*/0,
         /*smallest_seq=*/40, /*largest_seq=*/41,
         /*compensated_file_size=*/1000);
     const uint64_t l0_size = 4000;
-    const uint64_t lbase_size = l0_size * lbase_size_multiplier;
+    const uint64_t lbase_size = l0_size * lbase_size_multiplier * 2;
     Add(/*level=*/1, /*file_number=*/5U, /*smallest=*/"100",
         /*largest=*/"200", /*file_size=*/lbase_size, /*path_id=*/0,
         /*smallest_seq=*/0, /*largest_seq=*/0,

package/deps/rocksdb/rocksdb/db/compaction/compaction_service_job.cc

@@ -140,9 +140,13 @@ CompactionJob::ProcessKeyValueCompactionWithCompactionService(
     return compaction_status;
   }
 
+  // CompactionServiceJobStatus::kSuccess was returned, but somehow we failed to
+  // read the result. Consider this as an installation failure
   if (!s.ok()) {
     sub_compact->status = s;
     compaction_result.status.PermitUncheckedError();
+    db_options_.compaction_service->OnInstallation(
+        response.scheduled_job_id, CompactionServiceJobStatus::kFailure);
     return CompactionServiceJobStatus::kFailure;
   }
   sub_compact->status = compaction_result.status;
@@ -154,18 +158,14 @@ CompactionJob::ProcessKeyValueCompactionWithCompactionService(
     is_first_one = false;
   }
 
-  ROCKS_LOG_INFO(db_options_.info_log,
-                 "[%s] [JOB %d] Receive remote compaction result, output path: "
-                 "%s, files: %s",
-                 compaction_input.column_family.name.c_str(), job_id_,
-                 compaction_result.output_path.c_str(),
-                 output_files_oss.str().c_str());
-
-  if (!s.ok()) {
-    sub_compact->status = s;
-    return CompactionServiceJobStatus::kFailure;
-  }
+  ROCKS_LOG_INFO(
+      db_options_.info_log,
+      "[%s] [JOB %d] Received remote compaction result, output path: "
+      "%s, files: %s",
+      compaction_input.column_family.name.c_str(), job_id_,
+      compaction_result.output_path.c_str(), output_files_oss.str().c_str());
 
+  // Installation Starts
   for (const auto& file : compaction_result.output_files) {
     uint64_t file_num = versions_->NewFileNumber();
     auto src_file = compaction_result.output_path + "/" + file.file_name;
@@ -174,6 +174,8 @@ CompactionJob::ProcessKeyValueCompactionWithCompactionService(
     s = fs_->RenameFile(src_file, tgt_file, IOOptions(), nullptr);
     if (!s.ok()) {
       sub_compact->status = s;
+      db_options_.compaction_service->OnInstallation(
+          response.scheduled_job_id, CompactionServiceJobStatus::kFailure);
       return CompactionServiceJobStatus::kFailure;
     }
 
@@ -182,6 +184,8 @@ CompactionJob::ProcessKeyValueCompactionWithCompactionService(
     s = fs_->GetFileSize(tgt_file, IOOptions(), &file_size, nullptr);
     if (!s.ok()) {
       sub_compact->status = s;
+      db_options_.compaction_service->OnInstallation(
+          response.scheduled_job_id, CompactionServiceJobStatus::kFailure);
       return CompactionServiceJobStatus::kFailure;
     }
     meta.fd = FileDescriptor(file_num, compaction->output_path_id(), file_size,
@@ -206,6 +210,8 @@ CompactionJob::ProcessKeyValueCompactionWithCompactionService(
   RecordTick(stats_, REMOTE_COMPACT_READ_BYTES, compaction_result.bytes_read);
   RecordTick(stats_, REMOTE_COMPACT_WRITE_BYTES,
              compaction_result.bytes_written);
+  db_options_.compaction_service->OnInstallation(
+      response.scheduled_job_id, CompactionServiceJobStatus::kSuccess);
   return CompactionServiceJobStatus::kSuccess;
 }
 

package/deps/rocksdb/rocksdb/db/compaction/compaction_service_test.cc

@@ -108,6 +108,11 @@ class MyTestCompactionService : public CompactionService {
     }
   }
 
+  void OnInstallation(const std::string& /*scheduled_job_id*/,
+                      CompactionServiceJobStatus status) override {
+    final_updated_status_ = status;
+  }
+
   int GetCompactionNum() { return compaction_num_.load(); }
 
   CompactionServiceJobInfo GetCompactionInfoForStart() { return start_info_; }
@@ -136,6 +141,10 @@ class MyTestCompactionService : public CompactionService {
 
   void SetCanceled(bool canceled) { canceled_ = canceled; }
 
+  CompactionServiceJobStatus GetFinalCompactionServiceJobStatus() {
+    return final_updated_status_.load();
+  }
+
  private:
   InstrumentedMutex mutex_;
   std::atomic_int compaction_num_{0};
@@ -158,6 +167,8 @@ class MyTestCompactionService : public CompactionService {
   std::vector<std::shared_ptr<TablePropertiesCollectorFactory>>
       table_properties_collector_factories_;
   std::atomic_bool canceled_{false};
+  std::atomic<CompactionServiceJobStatus> final_updated_status_{
+      CompactionServiceJobStatus::kUseLocal};
 };
 
 class CompactionServiceTest : public DBTestBase {
@@ -255,6 +266,8 @@ TEST_F(CompactionServiceTest, BasicCompactions) {
 
   auto my_cs = GetCompactionService();
   ASSERT_GE(my_cs->GetCompactionNum(), 1);
+  ASSERT_EQ(CompactionServiceJobStatus::kSuccess,
+            my_cs->GetFinalCompactionServiceJobStatus());
 
   // make sure the compaction statistics is only recorded on the remote side
   ASSERT_GE(compactor_statistics->getTickerCount(COMPACT_WRITE_BYTES), 1);
@@ -437,6 +450,8 @@ TEST_F(CompactionServiceTest, InvalidResult) {
   Slice end(end_str);
   Status s = db_->CompactRange(CompactRangeOptions(), &start, &end);
   ASSERT_FALSE(s.ok());
+  ASSERT_EQ(CompactionServiceJobStatus::kFailure,
+            my_cs->GetFinalCompactionServiceJobStatus());
 }
 
 TEST_F(CompactionServiceTest, SubCompaction) {