@nxtedition/rocksdb 15.4.1 → 16.0.0

package/index.js

@@ -52,6 +52,12 @@ class RocksLevel extends AbstractLevel {
   }
 
   get sequence () {
+    if (this.status !== 'open') {
+      throw new ModuleError('Database is not open', {
+        code: 'LEVEL_DATABASE_NOT_OPEN'
+      })
+    }
+
     return binding.db_get_latest_sequence(this[kContext])
   }
 
@@ -112,7 +118,14 @@ class RocksLevel extends AbstractLevel {
   [kUnref] () {
     this[kRefs]--
     if (this[kRefs] === 0 && this[kPendingClose]) {
-      process.nextTick(this[kPendingClose])
+      // Perform the deferred native close now that all in-flight ops have
+      // drained. Note: kPendingClose holds the abstract-level _close callback,
+      // so we must call binding.db_close here (not just the callback) or the
+      // native DB and its directory lock would leak. nextTick avoids reentering
+      // the native layer from within the completing op's own callback.
+      const callback = this[kPendingClose]
+      this[kPendingClose] = null
+      process.nextTick(() => binding.db_close(this[kContext], callback))
     }
   }
 
@@ -243,10 +256,22 @@ class RocksLevel extends AbstractLevel {
       }
     }
 
-    binding.batch_write(this[kContext], batch, options ?? {}, (err, val) => {
+    // Hold a db ref for the duration of the write so close() defers db_close
+    // (which frees the native db on a worker thread) until it completes. The
+    // array-form batch uses a transient WriteBatch that is not an abstract-level
+    // resource, so it is not otherwise tracked across close.
+    this[kRef]()
+    try {
+      binding.batch_write(this[kContext], batch, options ?? {}, (err, val) => {
+        this[kUnref]()
+        binding.batch_clear(batch)
+        callback(err, val)
+      })
+    } catch (err) {
+      this[kUnref]()
       binding.batch_clear(batch)
-      callback(err, val)
-    })
+      process.nextTick(callback, err)
+    }
 
     return callback[kPromise]
   }
@@ -256,6 +281,12 @@ class RocksLevel extends AbstractLevel {
   }
 
   get identity () {
+    if (this.status !== 'open') {
+      throw new ModuleError('Database is not open', {
+        code: 'LEVEL_DATABASE_NOT_OPEN'
+      })
+    }
+
     return binding.db_get_identity(this[kContext])
   }
 
@@ -305,10 +336,21 @@ class RocksLevel extends AbstractLevel {
 
     const handle = binding.updates_init(this[kContext], options)
     try {
-      while (true) {
-        const value = await new Promise((resolve, reject) => {
-          binding.updates_next(handle, (err, val) => err ? reject(err) : resolve(val))
-        })
+      // Stop if the db is closed between yields, so we never call updates_next
+      // on a freed db.
+      while (this.status === 'open') {
+        // Hold a db ref for the duration of each updates_next so close() defers
+        // db_close (and the Database::Close() that resets this log iterator on a
+        // worker thread) until the in-flight read completes.
+        this[kRef]()
+        let value
+        try {
+          value = await new Promise((resolve, reject) => {
+            binding.updates_next(handle, (err, val) => err ? reject(err) : resolve(val))
+          })
+        } finally {
+          this[kUnref]()
+        }
         if (!value) {
           break
         }
@@ -328,7 +370,16 @@ class RocksLevel extends AbstractLevel {
       })
     }
 
-    binding.db_compact_range(this[kContext], options, callback)
+    this[kRef]()
+    try {
+      binding.db_compact_range(this[kContext], options, (err, val) => {
+        this[kUnref]()
+        callback(err, val)
+      })
+    } catch (err) {
+      this[kUnref]()
+      process.nextTick(callback, err)
+    }
 
     return callback[kPromise]
   }
@@ -342,7 +393,16 @@ class RocksLevel extends AbstractLevel {
       })
     }
 
-    binding.db_flush_wal(this[kContext], options?.sync ?? false, callback)
+    this[kRef]()
+    try {
+      binding.db_flush_wal(this[kContext], options?.sync ?? false, (err, val) => {
+        this[kUnref]()
+        callback(err, val)
+      })
+    } catch (err) {
+      this[kUnref]()
+      process.nextTick(callback, err)
+    }
 
     return callback[kPromise]
   }

package/iterator.js

@@ -15,6 +15,7 @@ const kFinished = Symbol('finished')
 const kFirst = Symbol('first')
 const kPosition = Symbol('position')
 const kBusy = Symbol('busy')
+const kPendingClose = Symbol('pendingClose')
 
 const kEmpty = Object.freeze([])
 
@@ -30,6 +31,7 @@ class Iterator extends AbstractIterator {
     this[kPosition] = 0
     this[kDB] = db
     this[kBusy] = false
+    this[kPendingClose] = null
   }
 
   [Symbol.asyncDispose] () {
@@ -41,7 +43,23 @@ class Iterator extends AbstractIterator {
   }
 
   _close (callback) {
-    return this._closeAsync(callback)
+    // If an async nextv/seek is in flight on a worker thread, defer the close
+    // until it completes so we never free the native rocksdb iterator while the
+    // worker is still reading it. The pending close is flushed from the async
+    // op's completion callback (see _flushPendingClose).
+    if (this[kBusy]) {
+      this[kPendingClose] = callback
+    } else {
+      this._closeAsync(callback)
+    }
+  }
+
+  _flushPendingClose () {
+    if (!this[kBusy] && this[kPendingClose]) {
+      const callback = this[kPendingClose]
+      this[kPendingClose] = null
+      this._closeAsync(callback)
+    }
   }
 
   _end (callback) {
@@ -92,14 +110,14 @@ class Iterator extends AbstractIterator {
       if (err) {
         callback(err)
       } else {
-        const { rows, finished } = val
+        const { rows, finished, limited } = val
 
         const entries = []
         for (let n = 0; n < rows.length; n += 2) {
           entries.push([rows[n + 0], rows[n + 1]])
         }
 
-        callback(null, entries, finished)
+        callback(null, entries, finished, limited)
       }
     })
 
@@ -147,6 +165,8 @@ class Iterator extends AbstractIterator {
         } else {
           callback(null)
         }
+
+        this._flushPendingClose()
       })
     } catch (err) {
       this[kBusy] = false
@@ -193,6 +213,8 @@ class Iterator extends AbstractIterator {
             this[kFinished] = result.finished
             callback(null, result)
           }
+
+          this._flushPendingClose()
         })
       }
     } catch (err) {

package/max_rev_operator.h

@@ -13,10 +13,14 @@ int compareRev(const rocksdb::Slice& a, const rocksdb::Slice& b) {
     return 1;
   }
 
-  std::size_t indexA = 0;
-  std::size_t indexB = 0;
-  const std::size_t endA = std::min<std::size_t>(a[indexA++], a.size());
-  const std::size_t endB = std::min<std::size_t>(b[indexB++], b.size());
+  // The first byte is a length prefix declaring the content length. Clamp it to
+  // the bytes actually available (size - 1) so malformed/truncated operands can
+  // never over-read, and cast through unsigned char so a prefix >= 0x80 is not
+  // sign-extended. endA/endB are exclusive end offsets: content is at [1, endX).
+  std::size_t indexA = 1;
+  std::size_t indexB = 1;
+  const std::size_t endA = 1 + std::min<std::size_t>(static_cast<unsigned char>(a[0]), a.size() - 1);
+  const std::size_t endB = 1 + std::min<std::size_t>(static_cast<unsigned char>(b[0]), b.size() - 1);
 
   // Compare the revision number
   auto result = 0;
@@ -52,7 +56,7 @@ int compareRev(const rocksdb::Slice& a, const rocksdb::Slice& b) {
     }
   }
 
-  return endA - endB;
+  return static_cast<int>(endA) - static_cast<int>(endB);
 }
 
 class MaxRevOperator : public rocksdb::MergeOperator {

package/package.json

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

package/deps/rocksdb/rocksdb/include/rocksdb/utilities/lua/rocks_lua_custom_library.h

@@ -1,43 +0,0 @@
-//  Copyright (c) 2016, 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
-#ifdef LUA
-
-// lua headers
-extern "C" {
-#include <lauxlib.h>
-#include <lua.h>
-#include <lualib.h>
-}
-
-namespace ROCKSDB_NAMESPACE {
-namespace lua {
-// A class that used to define custom C Library that is callable
-// from Lua script
-class RocksLuaCustomLibrary {
- public:
-  virtual ~RocksLuaCustomLibrary() {}
-  // The name of the C library.  This name will also be used as the table
-  // (namespace) in Lua that contains the C library.
-  virtual const char* Name() const = 0;
-
-  // Returns a "static const struct luaL_Reg[]", which includes a list of
-  // C functions.  Note that the last entry of this static array must be
-  // {nullptr, nullptr} as required by Lua.
-  //
-  // More details about how to implement Lua C libraries can be found
-  // in the official Lua document http://www.lua.org/pil/26.2.html
-  virtual const struct luaL_Reg* Lib() const = 0;
-
-  // A function that will be called right after the library has been created
-  // and pushed on the top of the lua_State.  This custom setup function
-  // allows developers to put additional table or constant values inside
-  // the same table / namespace.
-  virtual void CustomSetup(lua_State* /*L*/) const {}
-};
-}  // namespace lua
-}  // namespace ROCKSDB_NAMESPACE
-#endif  // LUA

package/deps/rocksdb/rocksdb/include/rocksdb/utilities/lua/rocks_lua_util.h

@@ -1,55 +0,0 @@
-//  Copyright (c) 2016, 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
-// lua headers
-extern "C" {
-#include <lauxlib.h>
-#include <lua.h>
-#include <lualib.h>
-}
-
-#ifdef LUA
-#include <string>
-#include <vector>
-
-#include "rocksdb/utilities/lua/rocks_lua_custom_library.h"
-
-namespace ROCKSDB_NAMESPACE {
-namespace lua {
-class LuaStateWrapper {
- public:
-  explicit LuaStateWrapper(const std::string& lua_script) {
-    lua_state_ = luaL_newstate();
-    Init(lua_script, {});
-  }
-  LuaStateWrapper(
-      const std::string& lua_script,
-      const std::vector<std::shared_ptr<RocksLuaCustomLibrary>>& libraries) {
-    lua_state_ = luaL_newstate();
-    Init(lua_script, libraries);
-  }
-  lua_State* GetLuaState() const { return lua_state_; }
-  ~LuaStateWrapper() { lua_close(lua_state_); }
-
- private:
-  void Init(
-      const std::string& lua_script,
-      const std::vector<std::shared_ptr<RocksLuaCustomLibrary>>& libraries) {
-    if (lua_state_) {
-      luaL_openlibs(lua_state_);
-      for (const auto& library : libraries) {
-        luaL_openlib(lua_state_, library->Name(), library->Lib(), 0);
-        library->CustomSetup(lua_state_);
-      }
-      luaL_dostring(lua_state_, lua_script.c_str());
-    }
-  }
-
-  lua_State* lua_state_;
-};
-}  // namespace lua
-}  // namespace ROCKSDB_NAMESPACE
-#endif  // LUA