RUBY-1347 Do not use sessions by default in parallel scan. (#974)

* RUBY-1347 Do not use sessions by default in parallel scan.

A user is able to explicitly provide a session still,
but the driver will execute the parallel scan outside of a session
by default.

* RUBY-1347 Skip session-requiring tests on old mongods

Author: p-mongo

lib/mongo/collection/view/readable.rb

@@ -553,30 +553,34 @@ def server_selector
         end
 
         def parallel_scan(cursor_count, options = {})
-          session = client.send(:get_session, @options)
+          if options[:session]
+            session = client.send(:get_session, @options)
+          else
+            session = nil
+          end
           server = server_selector.select_server(cluster)
           cmd = Operation::ParallelScan.new({
                   :coll_name => collection.name,
                   :db_name => database.name,
                   :cursor_count => cursor_count,
                   :read_concern => collection.read_concern,
-                  :session => session
+                  :session => session,
                 }.merge!(options))
           cmd.execute(server).cursor_ids.map do |cursor_id|
             result = if server.features.find_command_enabled?
-                       Operation::GetMore.new({
-                         :selector => {:getMore => cursor_id,
-                                       :collection => collection.name},
-                         :db_name => database.name,
-                         :session => session
-                       }).execute(server)
-                     else
-                       Operation::GetMore.new({
-                         :to_return => 0,
-                         :cursor_id => cursor_id,
-                         :db_name => database.name,
-                         :coll_name => collection.name
-                     }).execute(server)
+              Operation::GetMore.new({
+                :selector => {:getMore => cursor_id,
+                             :collection => collection.name},
+                :db_name => database.name,
+                :session => session,
+              }).execute(server)
+             else
+              Operation::GetMore.new({
+                :to_return => 0,
+                :cursor_id => cursor_id,
+                :db_name => database.name,
+                :coll_name => collection.name
+              }).execute(server)
             end
             Cursor.new(self, result, server, session: session)
           end

spec/mongo/collection_spec.rb

@@ -2376,6 +2376,33 @@ def generate
       it_behaves_like 'a failed operation using a session'
     end
 
+    context 'when a session is not provided' do
+      let(:client) { subscribed_client }
+      let(:collection) { client['test'] }
+
+      let(:cursors) do
+        collection.parallel_scan(2)
+      end
+
+      let(:operation) do
+        cursors.reduce(0) { |total, cursor| total + cursor.to_a.size }
+      end
+
+      let(:failed_operation) do
+        collection.parallel_scan(-2)
+      end
+
+      let(:command) do
+        operation
+        event = EventSubscriber.started_events.find { |cmd| cmd.command_name == 'parallelCollectionScan' }
+        expect(event).not_to be_nil
+        event.command
+      end
+
+      it_behaves_like 'an operation not using a session'
+      it_behaves_like 'a failed operation not using a session'
+    end
+
     context 'when a session supporting causal consistency is used' do
 
       let(:cursors) do
@@ -2388,7 +2415,9 @@ def generate
 
       let(:command) do
         operation
-        EventSubscriber.started_events.find { |cmd| cmd.command_name == 'parallelCollectionScan' }.command
+        event = EventSubscriber.started_events.find { |cmd| cmd.command_name == 'parallelCollectionScan' }
+        expect(event).not_to be_nil
+        event.command
       end
 
       it_behaves_like 'an operation supporting causally consistent reads'

spec/support/constraints.rb

@@ -14,6 +14,14 @@ def min_server_version(version)
     end
   end
 
+  def require_sessions
+    before do
+      unless sessions_enabled?
+        skip 'Sessions are not enabled'
+      end
+    end
+  end
+
   def require_topology(*topologies)
     topologies = topologies.map { |t| t.to_s }
     invalid_topologies = topologies - %w(single replica_set sharded)

spec/support/shared/session.rb

@@ -756,3 +756,110 @@
     end
   end
 end
+
+shared_examples 'an operation not using a session' do
+  require_sessions
+
+  describe 'operation execution' do
+
+    context 'when the client has a session' do
+
+      let(:session) do
+        client.start_session
+      end
+
+      let(:server_session) do
+        session.instance_variable_get(:@server_session)
+      end
+
+      let!(:before_last_use) do
+        server_session.last_use
+      end
+
+      let!(:before_operation_time) do
+        session.operation_time
+      end
+
+      let!(:operation_result) do
+        operation
+      end
+
+      after do
+        session.end_session
+      end
+
+      it 'does not send session id in command' do
+        expect(command).not_to have_key('lsid')
+      end
+
+      it 'does not update the last use value' do
+        expect(server_session.last_use).to eq(before_last_use)
+      end
+
+      it 'does not update the operation time value' do
+        expect(session.operation_time).to eq(before_operation_time)
+      end
+
+      it 'does not close the session when the operation completes' do
+        expect(session.ended?).to be(false)
+      end
+    end
+
+    context 'when the session is ended before it is used' do
+      let(:session) do
+        client.start_session
+      end
+
+      before do
+        session.end_session
+      end
+
+      let(:operation_result) do
+        operation
+      end
+
+      it 'does not raise an exception' do
+        expect {
+          operation_result
+        }.not_to raise_exception(Mongo::Error::InvalidSession)
+      end
+    end
+  end
+end
+
+shared_examples 'a failed operation not using a session' do
+  require_sessions
+
+  context 'when the operation fails' do
+
+    let!(:before_last_use) do
+      session.instance_variable_get(:@server_session).last_use
+    end
+
+    let!(:before_operation_time) do
+      session.operation_time
+    end
+
+    let!(:operation_result) do
+      sleep 0.2
+      begin; failed_operation; rescue => e; e; end
+    end
+
+    let(:session) do
+      client.start_session
+    end
+
+    it 'raises an error' do
+      expect([Mongo::Error::OperationFailure,
+              Mongo::Error::BulkWriteError]).to include(operation_result.class)
+    end
+
+    it 'does not update the last use value' do
+      expect(session.instance_variable_get(:@server_session).last_use).to eq(before_last_use)
+    end
+
+    it 'does not update the operation time value' do
+      expect(session.operation_time).to eq(before_operation_time)
+    end
+  end
+end