@nxtedition/rocksdb 5.2.17 → 5.2.21

package/binding.cc

@@ -41,7 +41,7 @@ static void iterator_do_close (napi_env env, Iterator* iterator, napi_value cb);
   NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], (void**)&iterator));
 
 #define NAPI_BATCH_CONTEXT() \
-  leveldb::WriteBatch* batch = nullptr; \
+  rocksdb::WriteBatch* batch = nullptr; \
   NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], (void**)&batch));
 
 static bool IsString (napi_env env, napi_value value) {
@@ -158,7 +158,7 @@ static std::string ToString (napi_env env, napi_value from, const std::string& d
   return defaultValue;
 }
 
-static std::string StringProperty (napi_env env, napi_value obj, const std::string& key) {
+static std::string StringProperty (napi_env env, napi_value obj, const std::string& key, const std::string& defaultValue = "") {
   if (HasProperty(env, obj, key)) {
     napi_value value = GetProperty(env, obj, key);
     if (IsString(env, value)) {
@@ -166,7 +166,7 @@ static std::string StringProperty (napi_env env, napi_value obj, const std::stri
     }
   }
 
-  return "";
+  return defaultValue;
 }
 
 static size_t StringOrBufferLength (napi_env env, napi_value value) {
@@ -267,7 +267,7 @@ struct BaseWorker {
     self->DoExecute();
   }
 
-  bool SetStatus (const leveldb::Status& status) {
+  bool SetStatus (const rocksdb::Status& status) {
     status_ = status;
     return status.ok();
   }
@@ -340,7 +340,7 @@ struct BaseWorker {
 private:
   napi_ref callbackRef_;
   napi_async_work asyncWork_;
-  leveldb::Status status_;
+  rocksdb::Status status_;
 };
 
 /**
@@ -352,17 +352,17 @@ struct Database {
       ref_(nullptr),
       priorityWork_(0) {}
 
-  leveldb::Status Open (const leveldb::Options& options,
+  rocksdb::Status Open (const rocksdb::Options& options,
                         const bool readOnly,
                         const char* location) {
     if (readOnly) {
-      leveldb::DB* db = nullptr;
+      rocksdb::DB* db = nullptr;
       const auto status = rocksdb::DB::OpenForReadOnly(options, location, &db);
       db_.reset(db);
       return status;
     } else {
-      leveldb::DB* db = nullptr;
-      const auto status = leveldb::DB::Open(options, location, &db);
+      rocksdb::DB* db = nullptr;
+      const auto status = rocksdb::DB::Open(options, location, &db);
       db_.reset(db);
       return status;
     }
@@ -372,36 +372,36 @@ struct Database {
     db_.reset();
   }
 
-  leveldb::Status Put (const leveldb::WriteOptions& options,
+  rocksdb::Status Put (const rocksdb::WriteOptions& options,
                        const std::string& key,
                        const std::string& value) {
     return db_->Put(options, db_->DefaultColumnFamily(), key, value);
   }
 
-  leveldb::Status Get (const leveldb::ReadOptions& options,
+  rocksdb::Status Get (const rocksdb::ReadOptions& options,
                        const std::string& key,
                        rocksdb::PinnableSlice& value) {
     return db_->Get(options, db_->DefaultColumnFamily(), key, &value);
   }
 
-  leveldb::Status Del (const leveldb::WriteOptions& options,
+  rocksdb::Status Del (const rocksdb::WriteOptions& options,
                        const std::string& key) {
     return db_->Delete(options, db_->DefaultColumnFamily(), key);
   }
 
-  leveldb::Status WriteBatch (const leveldb::WriteOptions& options,
-                              leveldb::WriteBatch* batch) {
+  rocksdb::Status WriteBatch (const rocksdb::WriteOptions& options,
+                              rocksdb::WriteBatch* batch) {
     return db_->Write(options, batch);
   }
 
-  uint64_t ApproximateSize (const leveldb::Range* range) {
+  uint64_t ApproximateSize (const rocksdb::Range* range) {
     uint64_t size = 0;
     db_->GetApproximateSizes(range, 1, &size);
     return size;
   }
 
-  void CompactRange (const leveldb::Slice* start,
-                     const leveldb::Slice* end) {
+  void CompactRange (const rocksdb::Slice* start,
+                     const rocksdb::Slice* end) {
     rocksdb::CompactRangeOptions options;
     db_->CompactRange(options, start, end);
   }
@@ -410,15 +410,15 @@ struct Database {
     db_->GetProperty(property, &value);
   }
 
-  const leveldb::Snapshot* NewSnapshot () {
+  const rocksdb::Snapshot* NewSnapshot () {
     return db_->GetSnapshot();
   }
 
-  leveldb::Iterator* NewIterator (const leveldb::ReadOptions& options) {
+  rocksdb::Iterator* NewIterator (const rocksdb::ReadOptions& options) {
     return db_->NewIterator(options);
   }
 
-  void ReleaseSnapshot (const leveldb::Snapshot* snapshot) {
+  void ReleaseSnapshot (const rocksdb::Snapshot* snapshot) {
     return db_->ReleaseSnapshot(snapshot);
   }
 
@@ -449,7 +449,7 @@ struct Database {
     return priorityWork_ > 0;
   }
 
-  std::unique_ptr<leveldb::DB> db_;
+  std::unique_ptr<rocksdb::DB> db_;
   BaseWorker* pendingCloseWorker_;
   std::set<Iterator*> iterators_;
   napi_ref ref_;
@@ -487,7 +487,7 @@ struct BaseIterator {
     : database_(database),
       snapshot_(database->NewSnapshot()),
       dbIterator_(database->NewIterator([&]{
-        leveldb::ReadOptions options;
+        rocksdb::ReadOptions options;
         options.fill_cache = fillCache;
         options.verify_checksums = false;
         options.snapshot = snapshot_;
@@ -617,19 +617,19 @@ struct BaseIterator {
     Next();
   }
 
-  leveldb::Slice CurrentKey () const {
+  rocksdb::Slice CurrentKey () const {
     return dbIterator_->key();
   }
 
-  leveldb::Slice CurrentValue () const {
+  rocksdb::Slice CurrentValue () const {
     return dbIterator_->value();
   }
 
-  leveldb::Status Status () const {
+  rocksdb::Status Status () const {
     return dbIterator_->status();
   }
 
-  bool OutOfRange (const leveldb::Slice& target) const {
+  bool OutOfRange (const rocksdb::Slice& target) const {
     if (lte_) {
       if (target.compare(*lte_) > 0) return true;
     } else if (lt_) {
@@ -648,8 +648,8 @@ struct BaseIterator {
   Database* database_;
 
 private:
-  const leveldb::Snapshot* snapshot_;
-  leveldb::Iterator* dbIterator_;
+  const rocksdb::Snapshot* snapshot_;
+  rocksdb::Iterator* dbIterator_;
   bool didSeek_;
   const bool reverse_;
   const std::string* lt_;
@@ -681,9 +681,6 @@ struct Iterator final : public BaseIterator {
       valueAsBuffer_(valueAsBuffer),
       highWaterMarkBytes_(highWaterMarkBytes),
       first_(true),
-      nexting_(false),
-      isClosing_(false),
-      closeWorker_(nullptr),
       ref_(nullptr) {
   }
 
@@ -740,9 +737,6 @@ struct Iterator final : public BaseIterator {
   const bool valueAsBuffer_;
   const uint32_t highWaterMarkBytes_;
   bool first_;
-  bool nexting_;
-  bool isClosing_;
-  BaseWorker* closeWorker_;
   std::vector<std::string> cache_;
 
 private:
@@ -755,7 +749,7 @@ private:
  * the guarantee that no db operations will be in-flight at this time.
  */
 static void env_cleanup_hook (void* arg) {
-  Database* database = reinterpret_cast<Database*>(arg);
+  auto database = reinterpret_cast<Database*>(arg);
 
   // Do everything that db_close() does but synchronously. We're expecting that GC
   // did not (yet) collect the database because that would be a user mistake (not
@@ -776,7 +770,7 @@ static void env_cleanup_hook (void* arg) {
 
 static void FinalizeDatabase (napi_env env, void* data, void* hint) {
   if (data) {
-    Database* database = (Database*)data;
+    auto database = reinterpret_cast<Database*>(data);
     napi_remove_env_cleanup_hook(env, env_cleanup_hook, database);
     if (database->ref_) napi_delete_reference(env, database->ref_);
     delete database;
@@ -784,7 +778,7 @@ static void FinalizeDatabase (napi_env env, void* data, void* hint) {
 }
 
 NAPI_METHOD(db_init) {
-  Database* database = new Database();
+  auto database = new Database();
   napi_add_env_cleanup_hook(env, env_cleanup_hook, database);
 
   napi_value result;
@@ -798,11 +792,7 @@ NAPI_METHOD(db_init) {
   return result;
 }
 
-/**
- * Worker class for opening a database.
- * TODO: shouldn't this be a PriorityWorker?
- */
-struct OpenWorker final : public BaseWorker {
+struct OpenWorker final : public PriorityWorker {
   OpenWorker (napi_env env,
               Database* database,
               napi_value callback,
@@ -818,14 +808,14 @@ struct OpenWorker final : public BaseWorker {
               const uint32_t cacheSize,
               const std::string& infoLogLevel,
               const bool readOnly)
-    : BaseWorker(env, database, callback, "leveldown.db.open"),
+    : PriorityWorker(env, database, callback, "leveldown.db.open"),
       readOnly_(readOnly),
       location_(location) {
     options_.create_if_missing = createIfMissing;
     options_.error_if_exists = errorIfExists;
     options_.compression = compression
-      ? leveldb::kSnappyCompression
-      : leveldb::kNoCompression;
+      ? rocksdb::kSnappyCompression
+      : rocksdb::kNoCompression;
     options_.write_buffer_size = writeBufferSize;
     options_.max_open_files = maxOpenFiles;
     options_.max_log_file_size = maxFileSize;
@@ -873,7 +863,7 @@ struct OpenWorker final : public BaseWorker {
     SetStatus(database_->Open(options_, readOnly_, location_.c_str()));
   }
 
-  leveldb::Options options_;
+  rocksdb::Options options_;
   const bool readOnly_;
   const std::string location_;
 };
@@ -933,13 +923,6 @@ NAPI_METHOD(db_close) {
 
   const auto callback = argv[1];
 
-  napi_value noop;
-  napi_create_function(env, nullptr, 0, noop_callback, nullptr, &noop);
-
-  for (auto it : database->iterators_) {
-    iterator_do_close(env, it, noop);
-  }
-  
   auto worker = new CloseWorker(env, database, callback);
 
   if (!database->HasPriorityWork()) {
@@ -963,7 +946,7 @@ struct PutWorker final : public PriorityWorker {
   }
 
   void DoExecute () override {
-    leveldb::WriteOptions options;
+    rocksdb::WriteOptions options;
     options.sync = sync_;
     SetStatus(database_->Put(options, key_, value_));
   }
@@ -1000,7 +983,7 @@ struct GetWorker final : public PriorityWorker {
   }
 
   void DoExecute () override {
-    leveldb::ReadOptions options;
+    rocksdb::ReadOptions options;
     options.fill_cache = fillCache_;
     SetStatus(database_->Get(options, key_, value_));
   }
@@ -1057,7 +1040,7 @@ struct GetManyWorker final : public PriorityWorker {
   void DoExecute () override {
     cache_.reserve(keys_.size());
 
-    leveldb::ReadOptions options;
+    rocksdb::ReadOptions options;
     options.snapshot = snapshot_;
     options.fill_cache = fillCache_;
     
@@ -1109,7 +1092,7 @@ private:
   const bool valueAsBuffer_;
   std::vector<rocksdb::PinnableSlice> cache_;
   const bool fillCache_;
-  const leveldb::Snapshot* snapshot_;
+  const rocksdb::Snapshot* snapshot_;
 };
 
 NAPI_METHOD(db_get_many) {
@@ -1139,7 +1122,7 @@ struct DelWorker final : public PriorityWorker {
   }
 
   void DoExecute () override {
-    leveldb::WriteOptions options;
+    rocksdb::WriteOptions options;
     options.sync = sync_;
     SetStatus(database_->Del(options, key_));
   }
@@ -1181,10 +1164,9 @@ struct ClearWorker final : public PriorityWorker {
 
     // TODO: add option
     const uint32_t hwm = 16 * 1024;
-    leveldb::WriteBatch batch;
 
-    leveldb::WriteOptions options;
-    options.sync = false;
+    rocksdb::WriteBatch batch;
+    rocksdb::WriteOptions options;
 
     while (true) {
       size_t bytesRead = 0;
@@ -1245,7 +1227,7 @@ struct ApproximateSizeWorker final : public PriorityWorker {
       start_(start), end_(end) {}
 
   void DoExecute () override {
-    leveldb::Range range(start_, end_);
+    rocksdb::Range range(start_, end_);
     size_ = database_->ApproximateSize(&range);
   }
 
@@ -1285,8 +1267,8 @@ struct CompactRangeWorker final : public PriorityWorker {
       start_(start), end_(end) {}
 
   void DoExecute () override {
-    leveldb::Slice start = start_;
-    leveldb::Slice end = end_;
+    rocksdb::Slice start = start_;
+    rocksdb::Slice end = end_;
     database_->CompactRange(&start, &end);
   }
 
@@ -1333,8 +1315,8 @@ struct DestroyWorker final : public BaseWorker {
   ~DestroyWorker () {}
 
   void DoExecute () override {
-    leveldb::Options options;
-    SetStatus(leveldb::DestroyDB(location_, options));
+    rocksdb::Options options;
+    SetStatus(rocksdb::DestroyDB(location_, options));
   }
 
   const std::string location_;
@@ -1360,8 +1342,8 @@ struct RepairWorker final : public BaseWorker {
       location_(location) {}
 
   void DoExecute () override {
-    leveldb::Options options;
-    SetStatus(leveldb::RepairDB(location_, options));
+    rocksdb::Options options;
+    SetStatus(rocksdb::RepairDB(location_, options));
   }
 
   const std::string location_;
@@ -1424,10 +1406,6 @@ NAPI_METHOD(iterator_seek) {
   NAPI_ARGV(2);
   NAPI_ITERATOR_CONTEXT();
 
-  if (iterator->isClosing_) {
-    napi_throw_error(env, nullptr, "iterator has closed");
-  }
-
   const auto target = ToString(env, argv[1]);
   iterator->first_ = true;
   iterator->Seek(target);
@@ -1455,28 +1433,14 @@ private:
   Iterator* iterator_;
 };
 
-/**
- * Called by NAPI_METHOD(iterator_) and also when closing
- * open iterators during NAPI_METHOD(db_close).
- */
-static void iterator_do_close (napi_env env, Iterator* iterator, napi_value cb) {
-  if (!iterator->isClosing_) {
-    auto worker = new CloseIteratorWorker(env, iterator, cb);
-    iterator->isClosing_ = true;
-
-    if (iterator->nexting_) {
-      iterator->closeWorker_ = worker;
-    } else {
-      worker->Queue(env);
-    }
-  }
-}
-
 NAPI_METHOD(iterator_close) {
   NAPI_ARGV(2);
   NAPI_ITERATOR_CONTEXT();
 
-  iterator_do_close(env, iterator, argv[1]);
+  const auto callback = argv[1];
+
+  auto worker = new CloseIteratorWorker(env, iterator, callback);
+  worker->Queue(env);
 
   return 0;
 }
@@ -1530,14 +1494,6 @@ struct NextWorker final : public BaseWorker {
   }
 
   void DoFinally (napi_env env) override {
-    // clean up & handle the next/end state
-    iterator_->nexting_ = false;
-
-    if (iterator_->closeWorker_) {
-      iterator_->closeWorker_->Queue(env);
-      iterator_->closeWorker_ = nullptr;
-    }
-
     BaseWorker::DoFinally(env);
   }
 
@@ -1557,48 +1513,63 @@ NAPI_METHOD(iterator_nextv) {
 
   const auto callback = argv[2];
 
-  if (iterator->isClosing_) {
-    napi_value argv = CreateCodeError(env, "LEVEL_ITERATOR_NOT_OPEN", "Iterator is not open");
-    NAPI_STATUS_THROWS(CallFunction(env, callback, 1, &argv));
-    return 0;
-  }
-
   auto worker = new NextWorker(env, iterator, size, callback);
-  iterator->nexting_ = true;
   worker->Queue(env);
 
   return 0;
 }
 
-/**
- * Worker class for batch write operation.
- */
 struct BatchWorker final : public PriorityWorker {
   BatchWorker (napi_env env,
                Database* database,
                napi_value callback,
-               leveldb::WriteBatch* batch,
-               const bool sync,
-               const bool hasData)
-    : PriorityWorker(env, database, callback, "rocks_level.batch.do"),
-      batch_(batch), hasData_(hasData) {
-    options_.sync = sync;
-  }
+               napi_value array,
+               const bool sync)
+    : PriorityWorker(env, database, callback, "rocks_level.batch.do"), sync_(sync) {
+    uint32_t length;
+    NAPI_STATUS_THROWS_VOID(napi_get_array_length(env, array, &length));
 
-  ~BatchWorker () {
-    delete batch_;
+    for (uint32_t i = 0; i < length; i++) {
+      napi_value element;
+      NAPI_STATUS_THROWS_VOID(napi_get_element(env, array, i, &element));
+
+      if (!IsObject(env, element)) continue;
+
+      const auto type = StringProperty(env, element, "type");
+
+      if (type == "del") {
+        if (!HasProperty(env, element, "key")) continue;
+        const auto key = ToString(env, GetProperty(env, element, "key"));
+
+        batch_.Delete(key);
+        if (!hasData_) hasData_ = true;
+      } else if (type == "put") {
+        if (!HasProperty(env, element, "key")) continue;
+        if (!HasProperty(env, element, "value")) continue;
+
+        const auto key = ToString(env, GetProperty(env, element, "key"));
+        const auto value = ToString(env, GetProperty(env, element, "value"));
+
+        batch_.Put(key, value);
+        if (!hasData_) hasData_ = true;
+      }
+    }
   }
 
   void DoExecute () override {
     if (hasData_) {
-      SetStatus(database_->WriteBatch(options_, batch_));
+      rocksdb::WriteOptions options;
+      options.sync = sync_;
+      SetStatus(database_->WriteBatch(options, &batch_));
+    } else {
+      SetStatus(rocksdb::Status::OK());
     }
   }
 
 private:
-  leveldb::WriteOptions options_;
-  leveldb::WriteBatch* batch_;
-  const bool hasData_;
+  rocksdb::WriteBatch batch_;
+  const bool sync_;
+  bool hasData_;
 };
 
 NAPI_METHOD(batch_do) {
@@ -1609,39 +1580,7 @@ NAPI_METHOD(batch_do) {
   const auto sync = BooleanProperty(env, argv[2], "sync", false);
   const auto callback = argv[3];
 
-  uint32_t length;
-  napi_get_array_length(env, array, &length);
-
-  leveldb::WriteBatch* batch = new leveldb::WriteBatch();
-  bool hasData = false;
-
-  for (uint32_t i = 0; i < length; i++) {
-    napi_value element;
-    napi_get_element(env, array, i, &element);
-
-    if (!IsObject(env, element)) continue;
-
-    std::string type = StringProperty(env, element, "type");
-
-    if (type == "del") {
-      if (!HasProperty(env, element, "key")) continue;
-      const auto key = ToString(env, GetProperty(env, element, "key"));
-
-      batch->Delete(key);
-      if (!hasData) hasData = true;
-    } else if (type == "put") {
-      if (!HasProperty(env, element, "key")) continue;
-      if (!HasProperty(env, element, "value")) continue;
-
-      const auto key = ToString(env, GetProperty(env, element, "key"));
-      const auto value = ToString(env, GetProperty(env, element, "value"));
-
-      batch->Put(key, value);
-      if (!hasData) hasData = true;
-    }
-  }
-
-  auto worker = new BatchWorker(env, database, callback, batch, sync, hasData);
+  auto worker = new BatchWorker(env, database, callback, array, sync);
   worker->Queue(env);
 
   return 0;
@@ -1649,7 +1588,7 @@ NAPI_METHOD(batch_do) {
 
 static void FinalizeBatch (napi_env env, void* data, void* hint) {
   if (data) {
-    delete reinterpret_cast<leveldb::WriteBatch*>(data);
+    delete reinterpret_cast<rocksdb::WriteBatch*>(data);
   }
 }
 
@@ -1657,12 +1596,10 @@ NAPI_METHOD(batch_init) {
   NAPI_ARGV(1);
   NAPI_DB_CONTEXT();
 
-  auto batch = new leveldb::WriteBatch();
+  auto batch = new rocksdb::WriteBatch();
 
   napi_value result;
-  NAPI_STATUS_THROWS(napi_create_external(env, batch,
-                                          FinalizeBatch,
-                                          nullptr, &result));
+  NAPI_STATUS_THROWS(napi_create_external(env, batch, FinalizeBatch, nullptr, &result));
   return result;
 }
 
@@ -1714,7 +1651,7 @@ struct BatchWriteWorker final : public PriorityWorker {
   }
 
   void DoExecute () override {
-    leveldb::WriteOptions options;
+    rocksdb::WriteOptions options;
     options.sync = sync_;
     SetStatus(database_->WriteBatch(options, batch_));
   }
@@ -1725,7 +1662,7 @@ struct BatchWriteWorker final : public PriorityWorker {
   }
 
 private:
-  leveldb::WriteBatch* batch_;
+  rocksdb::WriteBatch* batch_;
   const bool sync_;
   napi_ref batchRef_;
 };

package/binding.gyp

@@ -1,4 +1,7 @@
 {
+    "variables": {
+        "openssl_fips" : "0"
+    },
     "targets": [{
       "target_name": "leveldown"
     , "conditions": [

package/deps/rocksdb/rocksdb.gyp

@@ -1,4 +1,7 @@
 {
+  "variables": {
+    "openssl_fips" : "0"
+  },
   'targets': [{
     'target_name': 'rocksdb'
   , 'type': 'static_library'

package/deps/snappy/snappy.gyp

@@ -1,4 +1,7 @@
-{'targets': [{
+{
+  "variables": {
+    "openssl_fips" : "0"
+  }, 'targets': [{
     'variables': {
         'conditions': [
             ['OS=="linux"',   {'os_include': 'linux'}]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/rocksdb",
-  "version": "5.2.17",
+  "version": "5.2.21",
   "description": "A low-level Node.js RocksDB binding",
   "license": "MIT",
   "main": "index.js",