RUBY-1104 Change name to CursorReaper

Author: estolfo

lib/mongo/cluster.rb

@@ -13,7 +13,7 @@
 # limitations under the License.
 
 require 'mongo/cluster/topology'
-require 'mongo/cluster/cursor_manager'
+require 'mongo/cluster/cursor_reaper'
 
 module Mongo
 
@@ -43,7 +43,7 @@ class Cluster
     attr_reader :topology
 
     def_delegators :topology, :replica_set?, :replica_set_name, :sharded?, :single?, :unknown?
-    def_delegators :@cursor_manager, :register_cursor, :schedule_kill_cursor, :unregister_cursor
+    def_delegators :@cursor_reaper, :register_cursor, :schedule_kill_cursor, :unregister_cursor
 
     # Determine if this cluster of servers is equal to another object. Checks the
     # servers currently in the cluster, not what was configured.
@@ -116,8 +116,8 @@ def initialize(seeds, monitoring, options = Options::Redacted.new)
 
       seeds.each{ |seed| add(seed) }
 
-      @cursor_manager = CursorManager.new(self)
-      @cursor_manager.run
+      @cursor_reaper = CursorReaper.new(self)
+      @cursor_reaper.run
 
       ObjectSpace.define_finalizer(self, self.class.finalize(pools))
     end
@@ -136,10 +136,10 @@ def initialize(seeds, monitoring, options = Options::Redacted.new)
     # @since 2.2.0
     def self.finalize(pools)
       proc do
+        cursor_reaper.kill_cursors
         pools.values.each do |pool|
           pool.disconnect!
         end
-        cursor_manager.kill_cursors
       end
     end
 

lib/mongo/cluster/cursor_manager.rb renamed to lib/mongo/cluster/cursor_reaper.rb

@@ -21,22 +21,22 @@ class Cluster
     # cursors that have been garbage collected without being exhausted.
     #
     # @since 2.3.0
-    class CursorManager
+    class CursorReaper
       extend Forwardable
       include Retryable
 
-      # @return [ Mongo::Cluster ] The cluster associated with this cursor manager.
+      # @return [ Mongo::Cluster ] The cluster associated with this cursor reaper.
       attr_reader :cluster
 
-      # The default time interval for the cursor manager to send pending kill cursors operations.
+      # The default time interval for the cursor reaper to send pending kill cursors operations.
       #
       # @since 2.3.0
       FREQUENCY = 1.freeze
 
-      # Create a cursor manager.
+      # Create a cursor reaper.
       #
-      # @example Create a CursorManager.
-      #   Mongo::Cluster::CursorManager.new(cluster)
+      # @example Create a CursorReaper.
+      #   Mongo::Cluster::CursorReaper.new(cluster)
       #
       # @api private
       #
@@ -48,16 +48,16 @@ def initialize(cluster)
         @cluster = cluster
       end
 
-      # Start the cursor manager's reaper thread.
+      # Start the cursor reapers's thread.
       #
-      # @example Start the cursor manager's reaper thread.
-      #   manager.run
+      # @example Start the cursor reaper's thread.
+      #   reaper.run
       #
       # @api private
       #
       # @since 2.3.0
       def run
-        @reaper ||= Thread.new(FREQUENCY) do |i|
+        @thread ||= Thread.new(FREQUENCY) do |i|
           loop do
             sleep(i)
             kill_cursors
@@ -68,7 +68,7 @@ def run
       # Schedule a kill cursors operation to be eventually executed.
       #
       # @example Schedule a kill cursors operation.
-      #   manager.schedule_kill_cursor(id, op_spec, server)
+      #   cursor_reaper.schedule_kill_cursor(id, op_spec, server)
       #
       # @param [ Integer ] id The id of the cursor to kill.
       # @param [ Hash ] op_spec The spec for the kill cursors op.
@@ -89,7 +89,7 @@ def schedule_kill_cursor(id, op_spec, server)
       # Register a cursor id as active.
       #
       # @example Register a cursor as active.
-      #   manager.register_cursor(id)
+      #   cursor_reaper.register_cursor(id)
       #
       # @param [ Integer ] id The id of the cursor to register as active.
       #
@@ -107,7 +107,7 @@ def register_cursor(id)
       # Unregister a cursor id, indicating that it's no longer active.
       #
       # @example Unregister a cursor.
-      #   manager.unregister_cursor(id)
+      #   cursor_reaper.unregister_cursor(id)
       #
       # @param [ Integer ] id The id of the cursor to unregister.
       #
@@ -123,7 +123,7 @@ def unregister_cursor(id)
       # Execute all pending kill cursors operations.
       #
       # @example Execute pending kill cursors operations.
-      #   manager.kill_cursors
+      #   cursor_reaper.kill_cursors
       #
       # @api private
       #

lib/mongo/cursor.rb

@@ -65,6 +65,21 @@ def initialize(view, result, server)
                                                              server))
     end
 
+
+    # Finalize the cursor for garbage collection. Schedules this cursor to be included
+    # in a killCursors operation executed by the Cluster's CursorReaper.
+    #
+    # @example Finalize the cluster.
+    #   Cursor.finalize(id, cluster, op, server)
+    #
+    # @param [ Integer ] cursor_id The cursor's id.
+    # @param [ Mongo::Cluster ] cluster The cluster associated with this cursor and its server.
+    # @param [ Hash ] op_spec The killCursors operation specification.
+    # @param [ Mongo::Server ] server The server to send the killCursors operation to.
+    #
+    # @return [ Proc ] The Finalizer.
+    #
+    # @since 2.3.0
     def self.finalize(cursor_id, cluster, op_spec, server)
       proc { cluster.schedule_kill_cursor(cursor_id, op_spec, server) }
     end

spec/mongo/cluster/cursor_manager_spec.rb renamed to spec/mongo/cluster/cursor_reaper_spec.rb

@@ -1,47 +1,47 @@
 require 'spec_helper'
 
-describe Mongo::Cluster::CursorManager do
+describe Mongo::Cluster::CursorReaper do
 
   after do
     authorized_collection.delete_many
   end
 
-  let(:manager) do
+  let(:reaper) do
     described_class.new(authorized_client.cluster)
   end
 
   let(:active_cursors) do
-    manager.instance_variable_get(:@active_cursors)
+    reaper.instance_variable_get(:@active_cursors)
   end
 
   describe '#intialize' do
 
     it 'initializes a hash for servers and their kill cursors ops' do
-      expect(manager.instance_variable_get(:@to_kill)).to be_a(Hash)
+      expect(reaper.instance_variable_get(:@to_kill)).to be_a(Hash)
     end
 
     it 'initializes a set for the list of active cursors' do
-      expect(manager.instance_variable_get(:@active_cursors)).to be_a(Set)
+      expect(reaper.instance_variable_get(:@active_cursors)).to be_a(Set)
     end
   end
 
   describe '#run' do
 
     it 'starts a thread calling #kill_cursors' do
-      manager.run
-      expect(manager.instance_variable_get(:@reaper)).to be_a(Thread)
+      reaper.run
+      expect(reaper.instance_variable_get(:@thread)).to be_a(Thread)
     end
 
     context 'when run is called more than once' do
 
       let!(:reaper_thread) do
-        manager.run
-        manager.instance_variable_get(:@reaper)
+        reaper.run
+        reaper.instance_variable_get(:@reaper)
       end
 
       it 'only starts a thread once' do
-        manager.run
-        expect(manager.instance_variable_get(:@reaper)).to be(reaper_thread)
+        reaper.run
+        expect(reaper.instance_variable_get(:@reaper)).to be(reaper_thread)
       end
     end
 
@@ -51,17 +51,17 @@
       let(:cursor_id) { 1 }
       let(:op_spec_1) { double('op_spec_1') }
       let(:op_spec_2) { double('op_spec_2') }
-      let(:to_kill) { manager.instance_variable_get(:@to_kill)}
+      let(:to_kill) { reaper.instance_variable_get(:@to_kill)}
 
       before do
-        manager.register_cursor(cursor_id)
-        manager.schedule_kill_cursor(cursor_id, op_spec_1, server)
-        manager.run
-        sleep(Mongo::Cluster::CursorManager::FREQUENCY + 0.5)
+        reaper.register_cursor(cursor_id)
+        reaper.schedule_kill_cursor(cursor_id, op_spec_1, server)
+        reaper.run
+        sleep(Mongo::Cluster::CursorReaper::FREQUENCY + 0.5)
       end
 
       it 'executes the ops in the thread' do
-        expect(manager.instance_variable_get(:@to_kill).size).to eq(0)
+        expect(reaper.instance_variable_get(:@to_kill).size).to eq(0)
       end
     end
   end
@@ -72,18 +72,18 @@
     let(:cursor_id) { 1 }
     let(:op_spec_1) { double('op_spec_1') }
     let(:op_spec_2) { double('op_spec_2') }
-    let(:to_kill) { manager.instance_variable_get(:@to_kill)}
+    let(:to_kill) { reaper.instance_variable_get(:@to_kill)}
 
     context 'when the cursor is on the list of active cursors' do
 
       before do
-        manager.register_cursor(cursor_id)
+        reaper.register_cursor(cursor_id)
       end
 
       context 'when there is not a list already for the server' do
 
         before do
-          manager.schedule_kill_cursor(cursor_id, op_spec_1, server)
+          reaper.schedule_kill_cursor(cursor_id, op_spec_1, server)
         end
 
         it 'initializes the list of op specs to a set' do
@@ -95,8 +95,8 @@
       context 'when there is a list of ops already for the server' do
 
         before do
-          manager.schedule_kill_cursor(cursor_id, op_spec_1, server)
-          manager.schedule_kill_cursor(cursor_id, op_spec_2, server)
+          reaper.schedule_kill_cursor(cursor_id, op_spec_1, server)
+          reaper.schedule_kill_cursor(cursor_id, op_spec_2, server)
         end
 
         it 'adds the op to the server list' do
@@ -107,7 +107,7 @@
         context 'when the same op is added more than once' do
 
           before do
-            manager.schedule_kill_cursor(cursor_id, op_spec_2, server)
+            reaper.schedule_kill_cursor(cursor_id, op_spec_2, server)
           end
 
           it 'does not allow duplicates ops for a server' do
@@ -121,7 +121,7 @@
     context 'when the cursor is not on the list of active cursors' do
 
       before do
-        manager.schedule_kill_cursor(cursor_id, op_spec_1, server)
+        reaper.schedule_kill_cursor(cursor_id, op_spec_1, server)
       end
 
       it 'does not add the kill cursors op spec to the list' do
@@ -133,7 +133,7 @@
   describe '#register_cursor' do
 
     before do
-      manager.register_cursor(cursor_id)
+      reaper.register_cursor(cursor_id)
     end
 
     context 'when the cursor id is nil' do
@@ -175,8 +175,8 @@
     context 'when the cursor id is in the active cursors list' do
 
       before do
-        manager.register_cursor(2)
-        manager.unregister_cursor(2)
+        reaper.register_cursor(2)
+        reaper.unregister_cursor(2)
       end
 
       it 'removes the cursor id' do

spec/mongo/cursor_spec.rb

@@ -241,7 +241,7 @@
 
       before do
         authorized_collection.insert_many(documents)
-        cursor_manager.schedule_kill_cursor(cursor.id,
+        cursor_reaper.schedule_kill_cursor(cursor.id,
                                             cursor.send(:kill_cursors_op_spec),
                                             cursor.instance_variable_get(:@server))
       end
@@ -263,13 +263,13 @@
         view.instance_variable_get(:@cursor)
       end
 
-      let(:cursor_manager) do
-        authorized_client.cluster.instance_variable_get(:@cursor_manager)
+      let(:cursor_reaper) do
+        authorized_client.cluster.instance_variable_get(:@cursor_reaper)
       end
 
 
       it 'schedules a kill cursors op' do
-        sleep(Mongo::Cluster::CursorManager::FREQUENCY + 0.5)
+        sleep(Mongo::Cluster::CursorReaper::FREQUENCY + 0.5)
         expect {
           cursor.to_a
         }.to raise_exception(Mongo::Error::OperationFailure)
@@ -278,7 +278,7 @@
       context 'when the cursor is unregistered before the kill cursors operations are executed' do
 
         it 'does not send a kill cursors operation for the unregistered cursor' do
-          cursor_manager.unregister_cursor(cursor.id)
+          cursor_reaper.unregister_cursor(cursor.id)
           expect(cursor.to_a.size).to eq(documents.size)
         end
       end
@@ -312,13 +312,13 @@
         view.to_enum
       end
 
-      let(:cursor_manager) do
-        authorized_collection.client.cluster.instance_variable_get(:@cursor_manager)
+      let(:cursor_reaper) do
+        authorized_collection.client.cluster.instance_variable_get(:@cursor_reaper)
       end
 
       it 'removes the cursor id from the active cursors tracked by the cluster cursor manager' do
         enum.next
-        expect(cursor_manager.instance_variable_get(:@active_cursors)).not_to include(cursor_id)
+        expect(cursor_reaper.instance_variable_get(:@active_cursors)).not_to include(cursor_id)
       end
     end
   end