JAVA-610: Make DBCursor finalizer optional and disable it in all cases where there is no cursor maintained on the server

Author: jyemin

src/main/com/mongodb/DBApiLayer.java

@@ -378,6 +378,9 @@ class Result implements Iterator<DBObject> {
             _host = res._host;
             _decoder = decoder;
             init( res );
+            // Only enable finalizer if cursor finalization is enabled and there is actually a cursor that needs killing
+            _optionalFinalizer = _mongo.getMongoOptions().isCursorFinalizerEnabled() && res.cursor() != 0 ?
+                    new OptionalFinalizer() : null;
         }
 
         private void init( Response res ){
@@ -471,18 +474,6 @@ public String toString(){
             return "DBCursor";
         }
 
-        protected void finalize() throws Throwable {
-            if (_curResult != null) {
-                long curId = _curResult.cursor();
-                _curResult = null;
-                _cur = null;
-                if (curId != 0) {
-                    _deadCursorIds.add(new DeadCursor(curId, _host));
-                }
-            }
-            super.finalize();
-        }
-
         public long totalBytes(){
             return _totalBytes;
         }
@@ -533,6 +524,10 @@ public ServerAddress getServerAddress() {
             return _host;
         }
 
+        boolean hasFinalizer() {
+            return _optionalFinalizer != null;
+        }
+
         Response _curResult;
         Iterator<DBObject> _cur;
         int _batchSize;
@@ -547,6 +542,23 @@ public ServerAddress getServerAddress() {
         private List<Integer> _sizes = new ArrayList<Integer>();
         private int _numFetched = 0;
 
+        // This allows us to easily enable/disable finalizer for cleaning up un-closed cursors
+        private final OptionalFinalizer _optionalFinalizer;
+
+        private class OptionalFinalizer {
+            @Override
+            protected void finalize() {
+                if (_curResult != null) {
+                    long curId = _curResult.cursor();
+                    _curResult = null;
+                    _cur = null;
+                    if (curId != 0) {
+                        _deadCursorIds.add(new DeadCursor(curId, _host));
+                    }
+                }
+            }
+        }
+
     }  // class Result
 
     static class DeadCursor {

src/main/com/mongodb/DBCursor.java

@@ -693,6 +693,13 @@ public String toString() {
         return sb.toString();
     }
 
+    boolean hasFinalizer() {
+        if (_it == null || ! (_it instanceof Result)) {
+            return false;
+        }
+        return ((Result) _it).hasFinalizer();
+    }
+
     // ----  query setup ----
     private final DBCollection _collection;
     private final DBObject _query;

src/main/com/mongodb/MongoOptions.java

@@ -50,6 +50,7 @@ public void reset(){
         dbEncoderFactory = DefaultDBEncoder.FACTORY;
         socketFactory = SocketFactory.getDefault();
         description = null;
+        cursorFinalizerEnabled = true;
     }
 
     public MongoOptions copy() {
@@ -73,6 +74,7 @@ public MongoOptions copy() {
         m.dbEncoderFactory = dbEncoderFactory;
         m.socketFactory = socketFactory;
         m.description = description;
+        m.cursorFinalizerEnabled = cursorFinalizerEnabled;
         return m;
     }
 
@@ -226,6 +228,16 @@ else if (safe)
      */
     public SocketFactory socketFactory;
 
+    /**
+     * Sets whether there is a a finalize method created that cleans up instances of DBCursor that the client
+     * does not close.  If you are careful to always call the close method of DBCursor, then this can safely be set to false.
+     * @see com.mongodb.DBCursor#close().
+     * Default is true.
+     */
+    public boolean cursorFinalizerEnabled;
+
+
+
     public String toString(){
         StringBuilder buf = new StringBuilder();
         buf.append( "description=" ).append( description ).append( ", " );
@@ -245,7 +257,8 @@ public String toString(){
         buf.append( "w=" ).append( w ).append( ", " );
         buf.append( "wtimeout=" ).append( wtimeout ).append( ", " );
         buf.append( "fsync=" ).append( fsync ).append( ", " );
-        buf.append( "j=" ).append( j );
+        buf.append( "j=" ).append(j).append( ", " );
+        buf.append( "cursorFinalizerEnabled=").append( cursorFinalizerEnabled);
 
         return buf.toString();
     }
@@ -538,4 +551,21 @@ public ReadPreference getReadPreference() {
     public void setReadPreference(ReadPreference readPreference) {
         this.readPreference = readPreference;
     }
+
+
+    /**
+     *
+     * @return whether DBCursor finalizer is enabled
+     */
+    public boolean isCursorFinalizerEnabled() {
+        return cursorFinalizerEnabled;
+    }
+
+    /**
+     *
+     * @param cursorFinalizerEnabled whether cursor finalizer is enabled
+     */
+    public void setCursorFinalizerEnabled(final boolean cursorFinalizerEnabled) {
+        this.cursorFinalizerEnabled = cursorFinalizerEnabled;
+    }
 }

src/test/com/mongodb/DBCursorTest.java

@@ -16,13 +16,19 @@
 
 package com.mongodb;
 
-import java.io.IOException;
-import java.util.Iterator;
-
-import java.util.concurrent.*;
+import com.mongodb.util.TestCase;
 import org.testng.annotations.Test;
 
-import com.mongodb.util.TestCase;
+import java.io.IOException;
+import java.net.UnknownHostException;
+import java.util.Iterator;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
 
 public class DBCursorTest extends TestCase {
 
@@ -456,6 +462,49 @@ public void testSort(){
         	curmax = val;
         }
     }
+
+    @Test
+    public void testHasFinalizer() throws UnknownHostException {
+        DBCollection c = _db.getCollection( "HasFinalizerTest" );
+        c.drop();
+
+        for ( int i=0; i<1000; i++ )
+            c.save( new BasicDBObject("_id", i), WriteConcern.SAFE);
+
+        // finalizer is on by default so after calling hasNext should report that it has one
+        DBCursor cursor = c.find();
+        assertFalse(cursor.hasFinalizer());
+        cursor.hasNext();
+        assertTrue(cursor.hasFinalizer());
+        cursor.close();
+
+        // no finalizer if there is no cursor, as there should not be for a query with only one result
+        cursor = c.find(new BasicDBObject("_id", 1));
+        cursor.hasNext();
+        assertFalse(cursor.hasFinalizer());
+        cursor.close();
+
+        // no finalizer if there is no cursor, as there should not be for a query with negative batch size
+        cursor = c.find();
+        cursor.batchSize(-1);
+        cursor.hasNext();
+        assertFalse(cursor.hasFinalizer());
+        cursor.close();
+
+        // finally, no finalizer if disabled in mongo options
+        MongoOptions mongoOptions = new MongoOptions();
+        mongoOptions.cursorFinalizerEnabled = false;
+        Mongo m = new Mongo("127.0.0.1", mongoOptions);
+        try {
+            c = m.getDB(cleanupDB).getCollection("HasFinalizerTest");
+            cursor = c.find();
+            cursor.hasNext();
+            assertFalse(cursor.hasFinalizer());
+            cursor.close();
+        } finally {
+            m.close();
+        }
+    }
 
     final DB _db;
 

src/test/com/mongodb/MongoOptionsTest.java

@@ -50,6 +50,7 @@ public void testCopy() throws Exception {
         options.socketFactory = null;
         options.description = "cool";
         options.readPreference = ReadPreference.secondary();
+        options.cursorFinalizerEnabled = true;
 
         final MongoOptions copy = options.copy();
         assertEquals(options.connectionsPerHost, copy.connectionsPerHost);
@@ -71,6 +72,7 @@ public void testCopy() throws Exception {
         assertEquals(options.socketFactory, copy.socketFactory);
         assertEquals(options.description, copy.description);
         assertEquals(options.readPreference, copy.readPreference);
+        assertEquals(options.cursorFinalizerEnabled, copy.cursorFinalizerEnabled);
     }
 
     @Test
@@ -96,6 +98,7 @@ public void testGetterSetters() throws Exception {
         options.setSocketFactory(null);
         options.setDescription("very cool");
         options.setReadPreference(ReadPreference.secondary());
+        options.setCursorFinalizerEnabled(true);
 
         assertEquals(options.getConnectionsPerHost(), 100);
         assertEquals(options.getThreadsAllowedToBlockForConnectionMultiplier(), 101);
@@ -115,6 +118,7 @@ public void testGetterSetters() throws Exception {
         assertEquals(options.getSocketFactory(), null);
         assertEquals(options.getDescription(), "very cool");
         assertEquals(options.getReadPreference(), ReadPreference.secondary());
+        assertEquals(options.isCursorFinalizerEnabled(), true);
     }
 }