*/
protected final void disOwnNativeHandle() {
- owningHandle_.set(false);
- }
-
- @Override
- public void close() {
- if (owningHandle_.compareAndSet(true, false)) {
- disposeInternal();
- }
+ setReportLeak(false);
+ owningHandle_ = false;
}
/**
@@ -61,5 +54,10 @@ public abstract class AbstractImmutableNativeReference
* which all subclasses of {@code AbstractImmutableNativeReference} must
* implement to release their underlying native C++ objects.
*/
- protected abstract void disposeInternal();
+ protected abstract void disposeInternal(boolean owningHandle);
+
+ @Override
+ protected final void dispose() {
+ this.disposeInternal(this.owningHandle_);
+ }
}
diff --git a/java/src/main/java/org/rocksdb/AbstractNativeReference.java b/java/src/main/java/org/rocksdb/AbstractNativeReference.java
index 88b2963b6..36d1370bb 100644
--- a/java/src/main/java/org/rocksdb/AbstractNativeReference.java
+++ b/java/src/main/java/org/rocksdb/AbstractNativeReference.java
@@ -5,6 +5,16 @@
package org.rocksdb;
+import io.netty5.buffer.api.Drop;
+import io.netty5.buffer.api.Owned;
+import io.netty5.buffer.api.internal.LeakDetection;
+import io.netty5.buffer.api.internal.LifecycleTracer;
+import io.netty5.buffer.api.internal.ResourceSupport;
+import io.netty5.util.internal.SystemPropertyUtil;
+import java.lang.ref.Cleaner;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+
/**
* AbstractNativeReference is the base-class of all RocksDB classes that have
* a pointer to a native C++ {@code rocksdb} object.
@@ -27,6 +37,30 @@ package org.rocksdb;
*
*/
public abstract class AbstractNativeReference implements AutoCloseable {
+
+ static boolean leakDetectionEnabled = SystemPropertyUtil.getBoolean("io.netty5.buffer.leakDetectionEnabled", false);
+
+ private static final Cleaner cleaner = Cleaner.create();
+
+ private final AtomicInteger acquires; // Closed if negative.
+ private final LifecycleTracer tracer;
+ private final AtomicBoolean reportLeak;
+
+ protected AbstractNativeReference(boolean reportLeak) {
+ var tracer = LifecycleTracer.get();
+ var acquires = new AtomicInteger(0);
+ var reportLeakRef = new AtomicBoolean(reportLeak);
+ String name = leakDetectionEnabled ? this.getClass().getName() : "rocksdb reference";
+ cleaner.register(this, () -> {
+ if (reportLeakRef.get() && acquires.get() >= 0) {
+ LeakDetection.reportLeak(tracer, name);
+ }
+ });
+ this.tracer = tracer;
+ this.acquires = acquires;
+ this.reportLeak = reportLeakRef;
+ }
+
/**
* Returns true if we are responsible for freeing the underlying C++ object
*
@@ -34,15 +68,83 @@ public abstract class AbstractNativeReference implements AutoCloseable {
*/
protected abstract boolean isOwningHandle();
+ public boolean isAccessible() {
+ return acquires.get() >= 0;
+ }
+
+
/**
- * Frees the underlying C++ object
- *
- * It is strong recommended that the developer calls this after they
- * have finished using the object.
- *
- * Note, that once an instance of {@link AbstractNativeReference} has been
- * closed, calling any of its functions will lead to undefined
- * behavior.
+ * Record the current access location for debugging purposes.
+ * This information may be included if the resource throws a life-cycle related exception, or if it leaks.
+ * If this resource has already been closed, then this method has no effect.
+ *
+ * @param hint An optional hint about this access and its context. May be {@code null}.
*/
- @Override public abstract void close();
+ public void touch(Object hint) {
+ if (isAccessible()) {
+ tracer.touch(hint);
+ }
+ }
+
+ /**
+ * Decrement the reference count, and dispose of the resource if the last reference is closed.
+ *
+ * Note, this method is not thread-safe because Resources are meant to be thread-confined.
+ *
+ * Subclasses who wish to attach behaviour to the close action should override the {@link #makeInaccessible()}
+ * method instead, or make it part of their drop implementation.
+ *
+ * @throws IllegalStateException If this Resource has already been closed.
+ */
+ @Override
+ public final void close() {
+ if (acquires.get() == -1) {
+ throw attachTrace(new IllegalStateException("Double-free: Resource already closed and dropped."));
+ }
+ int acq = acquires.getAndDecrement();
+ tracer.close(acq);
+ if (acq == 0) {
+ // The 'acquires' was 0, now decremented to -1, which means we need to drop.
+ tracer.drop(0);
+ try {
+ this.dispose();
+ } finally {
+ makeInaccessible();
+ }
+ }
+ }
+
+ /**
+ * Called once
+ */
+ protected abstract void dispose();
+
+ /**
+ * Attach a trace of the life-cycle of this object as suppressed exceptions to the given throwable.
+ *
+ * @param throwable The throwable to attach a life-cycle trace to.
+ * @param The concrete exception type.
+ * @return The given exception, which can then be thrown.
+ */
+ protected E attachTrace(E throwable) {
+ return tracer.attachTrace(throwable);
+ }
+
+ /**
+ * Called when this resource needs to be considered inaccessible.
+ * This is called at the correct points, by the {@link ResourceSupport} class,
+ * when the resource is being closed or sent,
+ * and can be used to set further traps for accesses that makes accessibility checks cheap.
+ * There would normally not be any reason to call this directly from a sub-class.
+ */
+ protected void makeInaccessible() {
+ }
+
+ protected final boolean getReportLeak() {
+ return reportLeak.get();
+ }
+
+ protected final void setReportLeak(boolean reportLeak) {
+ this.reportLeak.set(reportLeak);
+ }
}
diff --git a/java/src/main/java/org/rocksdb/AbstractRocksIterator.java b/java/src/main/java/org/rocksdb/AbstractRocksIterator.java
index 1aade1b89..d2fbb3b06 100644
--- a/java/src/main/java/org/rocksdb/AbstractRocksIterator.java
+++ b/java/src/main/java/org/rocksdb/AbstractRocksIterator.java
@@ -123,10 +123,12 @@ public abstract class AbstractRocksIterator
* before freeing the native handle.
*/
@Override
- protected void disposeInternal() {
+ protected void disposeInternal(boolean owningHandle) {
+ if (owningHandle) {
if (parent_.isOwningHandle()) {
disposeInternal(nativeHandle_);
}
+ }
}
abstract boolean isValid0(long handle);
diff --git a/java/src/main/java/org/rocksdb/AbstractTransactionNotifier.java b/java/src/main/java/org/rocksdb/AbstractTransactionNotifier.java
index cbb49836d..d7703f1a4 100644
--- a/java/src/main/java/org/rocksdb/AbstractTransactionNotifier.java
+++ b/java/src/main/java/org/rocksdb/AbstractTransactionNotifier.java
@@ -47,8 +47,10 @@ public abstract class AbstractTransactionNotifier
* Otherwise an undefined behavior will occur.
*/
@Override
- protected void disposeInternal() {
- disposeInternal(nativeHandle_);
+ protected void disposeInternal(boolean owningHandle) {
+ if (owningHandle) {
+ disposeInternal(nativeHandle_);
+ }
}
protected final native void disposeInternal(final long handle);
}
diff --git a/java/src/main/java/org/rocksdb/ColumnFamilyHandle.java b/java/src/main/java/org/rocksdb/ColumnFamilyHandle.java
index 1ac0a35bb..a90439e0b 100644
--- a/java/src/main/java/org/rocksdb/ColumnFamilyHandle.java
+++ b/java/src/main/java/org/rocksdb/ColumnFamilyHandle.java
@@ -136,9 +136,11 @@ public class ColumnFamilyHandle extends RocksObject {
* initialized before freeing the native handle.
*/
@Override
- protected void disposeInternal() {
- if(rocksDB_.isOwningHandle()) {
- disposeInternal(nativeHandle_);
+ protected void disposeInternal(boolean owningHandle) {
+ if (owningHandle) {
+ if (rocksDB_.isOwningHandle()) {
+ disposeInternal(nativeHandle_);
+ }
}
}
diff --git a/java/src/main/java/org/rocksdb/Filter.java b/java/src/main/java/org/rocksdb/Filter.java
index 7f490cf59..44a40e746 100644
--- a/java/src/main/java/org/rocksdb/Filter.java
+++ b/java/src/main/java/org/rocksdb/Filter.java
@@ -27,8 +27,10 @@ public abstract class Filter extends RocksObject {
* Otherwise an undefined behavior will occur.
*/
@Override
- protected void disposeInternal() {
- disposeInternal(nativeHandle_);
+ protected void disposeInternal(boolean owningHandle) {
+ if (owningHandle) {
+ disposeInternal(nativeHandle_);
+ }
}
@Override
diff --git a/java/src/main/java/org/rocksdb/Logger.java b/java/src/main/java/org/rocksdb/Logger.java
index 00a5d5674..f4c0ec804 100644
--- a/java/src/main/java/org/rocksdb/Logger.java
+++ b/java/src/main/java/org/rocksdb/Logger.java
@@ -109,13 +109,15 @@ public abstract class Logger extends RocksCallbackObject {
protected native byte infoLogLevel(long handle);
/**
- * We override {@link RocksCallbackObject#disposeInternal()}
+ * We override {@link RocksCallbackObject#disposeInternal(boolean)}
* as disposing of a rocksdb::LoggerJniCallback requires
* a slightly different approach as it is a std::shared_ptr
*/
@Override
- protected void disposeInternal() {
- disposeInternal(nativeHandle_);
+ protected void disposeInternal(boolean owningHandle) {
+ if (owningHandle) {
+ disposeInternal(nativeHandle_);
+ }
}
private native void disposeInternal(final long handle);
diff --git a/java/src/main/java/org/rocksdb/NativeComparatorWrapper.java b/java/src/main/java/org/rocksdb/NativeComparatorWrapper.java
index 6acc146f7..db9780c78 100644
--- a/java/src/main/java/org/rocksdb/NativeComparatorWrapper.java
+++ b/java/src/main/java/org/rocksdb/NativeComparatorWrapper.java
@@ -46,13 +46,15 @@ public abstract class NativeComparatorWrapper
}
/**
- * We override {@link RocksCallbackObject#disposeInternal()}
+ * We override {@link RocksCallbackObject#disposeInternal(boolean)}
* as disposing of a native rocksdb::Comparator extension requires
* a slightly different approach as it is not really a RocksCallbackObject
*/
@Override
- protected void disposeInternal() {
- disposeInternal(nativeHandle_);
+ protected void disposeInternal(boolean owningHandle) {
+ if (owningHandle) {
+ disposeInternal(nativeHandle_);
+ }
}
private native void disposeInternal(final long handle);
diff --git a/java/src/main/java/org/rocksdb/OptimisticTransactionDB.java b/java/src/main/java/org/rocksdb/OptimisticTransactionDB.java
index 5a2e1f3ed..5617b2da1 100644
--- a/java/src/main/java/org/rocksdb/OptimisticTransactionDB.java
+++ b/java/src/main/java/org/rocksdb/OptimisticTransactionDB.java
@@ -109,35 +109,23 @@ public class OptimisticTransactionDB extends RocksDB
* @throws RocksDBException if an error occurs whilst closing.
*/
public void closeE() throws RocksDBException {
- if (owningHandle_.compareAndSet(true, false)) {
- try {
- closeDatabase(nativeHandle_);
- } finally {
- disposeInternal();
- }
+ this.close();
+ RocksDBException closeEx = this.closeEx;
+ if (closeEx != null) {
+ this.closeEx = null;
+ throw closeEx;
}
}
- /**
- * This is similar to {@link #closeE()} except that it
- * silently ignores any errors.
- *
- * This will not fsync the WAL files.
- * If syncing is required, the caller must first call {@link #syncWal()}
- * or {@link #write(WriteOptions, WriteBatch)} using an empty write batch
- * with {@link WriteOptions#setSync(boolean)} set to true.
- *
- * See also {@link #close()}.
- */
@Override
- public void close() {
- if (owningHandle_.compareAndSet(true, false)) {
+ protected void disposeInternal(boolean owningHandle) {
+ if (owningHandle) {
try {
closeDatabase(nativeHandle_);
- } catch (final RocksDBException e) {
- // silently ignore the error report
+ } catch (RocksDBException e) {
+ closeEx = e;
} finally {
- disposeInternal();
+ super.disposeInternal(true);
}
}
}
diff --git a/java/src/main/java/org/rocksdb/RocksCallbackObject.java b/java/src/main/java/org/rocksdb/RocksCallbackObject.java
index 8d7a867ee..5258c564d 100644
--- a/java/src/main/java/org/rocksdb/RocksCallbackObject.java
+++ b/java/src/main/java/org/rocksdb/RocksCallbackObject.java
@@ -65,8 +65,10 @@ public abstract class RocksCallbackObject extends
* Deletes underlying C++ native callback object pointer
*/
@Override
- protected void disposeInternal() {
- disposeInternal(nativeHandle_);
+ protected void disposeInternal(boolean owningHandle) {
+ if (owningHandle) {
+ disposeInternal(nativeHandle_);
+ }
}
private native void disposeInternal(final long handle);
diff --git a/java/src/main/java/org/rocksdb/RocksDB.java b/java/src/main/java/org/rocksdb/RocksDB.java
index 9a8a0c384..1d12ee57f 100644
--- a/java/src/main/java/org/rocksdb/RocksDB.java
+++ b/java/src/main/java/org/rocksdb/RocksDB.java
@@ -41,6 +41,8 @@ public class RocksDB extends RocksObject {
private final List ownedColumnFamilyHandles = new ArrayList<>();
+ protected RocksDBException closeEx = null;
+
/**
* Loads the necessary library files.
* Calling this method twice will have no effect.
@@ -609,45 +611,28 @@ public class RocksDB extends RocksObject {
* @throws RocksDBException if an error occurs whilst closing.
*/
public void closeE() throws RocksDBException {
- for (final ColumnFamilyHandle columnFamilyHandle : ownedColumnFamilyHandles) {
- columnFamilyHandle.close();
- }
- ownedColumnFamilyHandles.clear();
-
- if (owningHandle_.compareAndSet(true, false)) {
- try {
- closeDatabase(nativeHandle_);
- } finally {
- disposeInternal();
- }
+ this.close();
+ RocksDBException closeEx = this.closeEx;
+ if (closeEx != null) {
+ this.closeEx = null;
+ throw closeEx;
}
}
- /**
- * This is similar to {@link #closeE()} except that it
- * silently ignores any errors.
- *
- * This will not fsync the WAL files.
- * If syncing is required, the caller must first call {@link #syncWal()}
- * or {@link #write(WriteOptions, WriteBatch)} using an empty write batch
- * with {@link WriteOptions#setSync(boolean)} set to true.
- *
- * See also {@link #close()}.
- */
@Override
- public void close() {
+ protected void disposeInternal(boolean owningHandle) {
for (final ColumnFamilyHandle columnFamilyHandle : ownedColumnFamilyHandles) {
columnFamilyHandle.close();
}
ownedColumnFamilyHandles.clear();
- if (owningHandle_.compareAndSet(true, false)) {
+ if (owningHandle) {
try {
closeDatabase(nativeHandle_);
- } catch (final RocksDBException e) {
- // silently ignore the error report
+ } catch (RocksDBException e) {
+ closeEx = e;
} finally {
- disposeInternal();
+ super.disposeInternal(true);
}
}
}
diff --git a/java/src/main/java/org/rocksdb/RocksMutableObject.java b/java/src/main/java/org/rocksdb/RocksMutableObject.java
index e92289dc0..6b1757bf7 100644
--- a/java/src/main/java/org/rocksdb/RocksMutableObject.java
+++ b/java/src/main/java/org/rocksdb/RocksMutableObject.java
@@ -5,6 +5,9 @@
package org.rocksdb;
+import io.netty5.buffer.api.Drop;
+import io.netty5.buffer.api.Owned;
+
/**
* RocksMutableObject is an implementation of {@link AbstractNativeReference}
* whose reference to the underlying native C++ object can change.
@@ -23,9 +26,11 @@ public abstract class RocksMutableObject extends AbstractNativeReference {
private boolean owningHandle_;
protected RocksMutableObject() {
+ super(false);
}
protected RocksMutableObject(final long nativeHandle) {
+ super(true);
this.nativeHandle_ = nativeHandle;
this.owningHandle_ = true;
}
@@ -52,11 +57,12 @@ public abstract class RocksMutableObject extends AbstractNativeReference {
final boolean owningNativeHandle) {
this.nativeHandle_ = nativeHandle;
this.owningHandle_ = owningNativeHandle;
+ this.setReportLeak(owningNativeHandle);
}
@Override
protected synchronized boolean isOwningHandle() {
- return this.owningHandle_;
+ return this.owningHandle_ && isAccessible();
}
/**
@@ -70,12 +76,10 @@ public abstract class RocksMutableObject extends AbstractNativeReference {
return this.nativeHandle_;
}
- @Override
- public synchronized final void close() {
+ @Override protected synchronized void dispose() {
if (isOwningHandle()) {
disposeInternal();
- this.owningHandle_ = false;
- this.nativeHandle_ = 0;
+ nativeHandle_ = 0;
}
}
diff --git a/java/src/main/java/org/rocksdb/RocksObject.java b/java/src/main/java/org/rocksdb/RocksObject.java
index f07e1018a..e15a5dc98 100644
--- a/java/src/main/java/org/rocksdb/RocksObject.java
+++ b/java/src/main/java/org/rocksdb/RocksObject.java
@@ -33,8 +33,10 @@ public abstract class RocksObject extends AbstractImmutableNativeReference {
* Deletes underlying C++ object pointer.
*/
@Override
- protected void disposeInternal() {
- disposeInternal(nativeHandle_);
+ protected void disposeInternal(boolean owningHandle) {
+ if (owningHandle) {
+ disposeInternal(nativeHandle_);
+ }
}
protected abstract void disposeInternal(final long handle);
diff --git a/java/src/main/java/org/rocksdb/TransactionDB.java b/java/src/main/java/org/rocksdb/TransactionDB.java
index 86f25fe15..04805137a 100644
--- a/java/src/main/java/org/rocksdb/TransactionDB.java
+++ b/java/src/main/java/org/rocksdb/TransactionDB.java
@@ -117,35 +117,23 @@ public class TransactionDB extends RocksDB
* @throws RocksDBException if an error occurs whilst closing.
*/
public void closeE() throws RocksDBException {
- if (owningHandle_.compareAndSet(true, false)) {
- try {
- closeDatabase(nativeHandle_);
- } finally {
- disposeInternal();
- }
+ this.close();
+ RocksDBException closeEx = this.closeEx;
+ if (closeEx != null) {
+ this.closeEx = null;
+ throw closeEx;
}
}
- /**
- * This is similar to {@link #closeE()} except that it
- * silently ignores any errors.
- *
- * This will not fsync the WAL files.
- * If syncing is required, the caller must first call {@link #syncWal()}
- * or {@link #write(WriteOptions, WriteBatch)} using an empty write batch
- * with {@link WriteOptions#setSync(boolean)} set to true.
- *
- * See also {@link #close()}.
- */
@Override
- public void close() {
- if (owningHandle_.compareAndSet(true, false)) {
+ protected void disposeInternal(boolean owningHandle) {
+ if (owningHandle) {
try {
closeDatabase(nativeHandle_);
- } catch (final RocksDBException e) {
- // silently ignore the error report
+ } catch (RocksDBException e) {
+ closeEx = e;
} finally {
- disposeInternal();
+ super.disposeInternal(true);
}
}
}
diff --git a/java/src/main/java/org/rocksdb/TtlDB.java b/java/src/main/java/org/rocksdb/TtlDB.java
index a7adaf4b2..3b07410ef 100644
--- a/java/src/main/java/org/rocksdb/TtlDB.java
+++ b/java/src/main/java/org/rocksdb/TtlDB.java
@@ -155,35 +155,23 @@ public class TtlDB extends RocksDB {
* @throws RocksDBException if an error occurs whilst closing.
*/
public void closeE() throws RocksDBException {
- if (owningHandle_.compareAndSet(true, false)) {
- try {
- closeDatabase(nativeHandle_);
- } finally {
- disposeInternal();
- }
+ this.close();
+ RocksDBException closeEx = this.closeEx;
+ if (closeEx != null) {
+ this.closeEx = null;
+ throw closeEx;
}
}
- /**
- * Close the TtlDB instance and release resource.
- *
- *
- * This will not fsync the WAL files.
- * If syncing is required, the caller must first call {@link #syncWal()}
- * or {@link #write(WriteOptions, WriteBatch)} using an empty write batch
- * with {@link WriteOptions#setSync(boolean)} set to true.
- *
- * See also {@link #close()}.
- */
@Override
- public void close() {
- if (owningHandle_.compareAndSet(true, false)) {
+ protected void disposeInternal(boolean owningHandle) {
+ if (owningHandle) {
try {
closeDatabase(nativeHandle_);
- } catch (final RocksDBException e) {
- // silently ignore the error report
+ } catch (RocksDBException e) {
+ closeEx = e;
} finally {
- disposeInternal();
+ super.disposeInternal(true);
}
}
}
diff --git a/java/src/main/java/org/rocksdb/WBWIRocksIterator.java b/java/src/main/java/org/rocksdb/WBWIRocksIterator.java
index ce146eb3f..2033b38e2 100644
--- a/java/src/main/java/org/rocksdb/WBWIRocksIterator.java
+++ b/java/src/main/java/org/rocksdb/WBWIRocksIterator.java
@@ -93,10 +93,8 @@ public class WBWIRocksIterator
}
}
- @Override
- public void close() {
+ @Override protected void disposeInternal(boolean owningHandle) {
entry.close();
- super.close();
}
/**