mongo 2.12.4 → 2.13.0.beta1

data/spec/integration/connection_spec.rb

@@ -1,4 +1,5 @@
 require 'spec_helper'
+require 'runners/sdam_monitoring'
 
 describe 'Connections' do
   clean_slate

data/spec/integration/crud_spec.rb

@@ -7,6 +7,34 @@ describe 'CRUD operations' do
     collection.delete_many
   end
 
+  describe 'find' do
+    context 'when allow_disk_use is true' do
+      # Other cases are adequately covered by spec tests.
+      context 'on server version < 3.2' do
+        max_server_fcv '3.0'
+
+        it 'raises an exception' do
+          expect do
+            collection.find({}, { allow_disk_use: true }).first
+          end.to raise_error(Mongo::Error::UnsupportedOption, /The MongoDB server handling this request does not support the allow_disk_use option on this command./)
+        end
+      end
+    end
+
+    context 'when allow_disk_use is false' do
+      # Other cases are adequately covered by spec tests.
+      context 'on server version < 3.2' do
+        max_server_fcv '3.0'
+
+        it 'raises an exception' do
+          expect do
+            collection.find({}, { allow_disk_use: false }).first
+          end.to raise_error(Mongo::Error::UnsupportedOption, /The MongoDB server handling this request does not support the allow_disk_use option on this command./)
+        end
+      end
+    end
+  end
+
   describe 'insert' do
     context 'inserting a BSON::Int64' do
       before do

data/spec/integration/cursor_reaping_spec.rb

@@ -5,19 +5,23 @@ describe 'Cursor reaping' do
   # in MRI, I don't currently know how to force GC to run in JRuby
   only_mri
 
-  let(:client) { subscribed_client }
+  let(:subscriber) { EventSubscriber.new }
+
+  let(:client) do
+    authorized_client.tap do |client|
+      client.subscribe(Mongo::Monitoring::COMMAND, subscriber)
+    end
+  end
+
   let(:collection) { client['cursor_reaping_spec'] }
 
-  before(:all) do
+  before do
     data = [{a: 1}] * 10
-    ClientRegistry.instance.global_client('subscribed')['cursor_reaping_spec'].insert_many(data)
+    authorized_client['cursor_reaping_spec'].delete_many
+    authorized_client['cursor_reaping_spec'].insert_many(data)
   end
 
   context 'a no-timeout cursor' do
-    before do
-      EventSubscriber.clear_events!
-    end
-
     it 'reaps nothing when we do not query' do
       # this is a base line test to ensure that the reaps in the other test
       # aren't done on some global cursor
@@ -26,7 +30,7 @@ describe 'Cursor reaping' do
       # just the scope, no query is happening
       collection.find.batch_size(2).no_cursor_timeout
 
-      events = EventSubscriber.started_events.select do |event|
+      events = subscriber.started_events.select do |event|
         event.command['killCursors']
       end
 
@@ -58,14 +62,14 @@ describe 'Cursor reaping' do
       # force periodic executor to run because its frequency is not configurable
       client.cluster.instance_variable_get('@periodic_executor').execute
 
-      started_event = EventSubscriber.started_events.detect do |event|
+      started_event = subscriber.started_events.detect do |event|
         event.command['killCursors'] &&
         event.command['cursors'].map { |c| Utils.int64_value(c) }.include?(cursor_id)
       end
 
       expect(started_event).not_to be_nil
 
-      succeeded_event = EventSubscriber.succeeded_events.detect do |event|
+      succeeded_event = subscriber.succeeded_events.detect do |event|
         event.command_name == 'killCursors' && event.request_id == started_event.request_id
       end
 

data/spec/integration/fork_reconnect_spec.rb

@@ -0,0 +1,143 @@
+require 'spec_helper'
+
+describe 'fork reconnect' do
+  require_fork
+  only_mri
+
+  # On multi-shard sharded clusters a succeeding write request does not
+  # guarantee that the next operation will succeed (since it could be sent to
+  # another shard with a dead connection).
+  require_no_multi_shard
+
+  # On Ruby 2.3 $?.exitstatus is sometimes nil after Process.wait returns which
+  # is not supposed to happen.
+  ruby_version_gte '2.4'
+
+  let(:client) { authorized_client }
+  let(:server) { client.cluster.next_primary }
+
+  describe 'monitoring connection' do
+    let(:monitor) do
+      Mongo::Server::Monitor.new(server, [], Mongo::Monitoring.new, server.options)
+    end
+
+    it 'reconnects' do
+      monitor.send(:do_scan).should be_a(Hash)
+
+      socket = monitor.connection.send(:socket).send(:socket)
+      (socket.is_a?(Socket) || socket.is_a?(OpenSSL::SSL::SSLSocket)).should be true
+
+      if pid = fork
+        pid, status = Process.wait2(pid)
+        status.exitstatus.should == 0
+      else
+        monitor.send(:do_scan).should be_a(Hash)
+
+        child_socket = monitor.connection.send(:socket).send(:socket)
+        # fileno of child_socket may equal to fileno of socket,
+        # as socket would've been closed first and file descriptors can be
+        # reused by the kernel.
+        child_socket.object_id.should_not == socket.object_id
+
+        # Exec so that we do not close any clients etc. in the child.
+        exec('/bin/true')
+      end
+
+      # Connection should remain serviceable in the parent.
+      # The operation here will be invoked again, since the earlier invocation
+      # was in the child process.
+      monitor.send(:do_scan).should be_a(Hash)
+
+      # The child closes the connection's socket, but this races with the
+      # parent. The parent can retain the original socket for a while.
+    end
+  end
+
+  describe 'non-monitoring connection' do
+    let(:connection) do
+      Mongo::Server::Connection.new(server, server.options)
+    end
+
+    let(:operation) do
+      connection.ping.should be true
+    end
+
+    it 'does not reconnect' do
+      connection.connect!
+
+      socket = connection.send(:socket).send(:socket)
+      (socket.is_a?(Socket) || socket.is_a?(OpenSSL::SSL::SSLSocket)).should be true
+
+      if pid = fork
+        pid, status = Process.wait2(pid)
+        status.exitstatus.should == 0
+      else
+        Utils.wrap_forked_child do
+          operation
+
+          child_socket = connection.send(:socket).send(:socket)
+          # fileno of child_socket may equal to fileno of socket,
+          # as socket would've been closed first and file descriptors can be
+          # reused by the kernel.
+          child_socket.object_id.should == socket.object_id
+        end
+      end
+
+      # The child closes the connection's socket, but this races with the
+      # parent. The parent can retain the original socket for a while.
+    end
+  end
+
+  describe 'connection pool' do
+
+    it 'creates a new connection in child' do
+      conn_id = server.with_connection do |connection|
+        connection.id
+      end
+
+      if pid = fork
+        pid, status = Process.wait2(pid)
+        status.exitstatus.should == 0
+      else
+        Utils.wrap_forked_child do
+          new_conn_id = server.with_connection do |connection|
+            connection.id
+          end
+
+          new_conn_id.should_not == conn_id
+        end
+      end
+
+      parent_conn_id = server.with_connection do |connection|
+        connection.id
+      end
+
+      parent_conn_id.should == conn_id
+    end
+  end
+
+  describe 'client' do
+    it 'works after fork' do
+      # Perform a write so that we discover the current primary.
+      # Previous test may have stepped down the server that authorized client
+      # considers the primary.
+      # In standalone deployments there are no retries, hence execute the
+      # operation twice manually.
+      client['foo'].insert_one(test: 1) rescue nil
+      client['foo'].insert_one(test: 1)
+
+      if pid = fork
+        pid, status = Process.wait2(pid)
+        status.exitstatus.should == 0
+      else
+        Utils.wrap_forked_child do
+          client.database.command(ismaster: 1).should be_a(Mongo::Operation::Result)
+        end
+      end
+
+      # Perform a read which can be retried, so that the socket close
+      # performed by the child is recovered from.
+      client['foo'].find(test: 1)
+    end
+  end
+end

data/spec/integration/get_more_spec.rb

@@ -4,8 +4,16 @@ describe 'getMore operation' do
   # https://jira.mongodb.org/browse/RUBY-1987
   min_server_fcv '3.2'
 
+  let(:subscriber) { EventSubscriber.new }
+
+  let(:client) do
+    authorized_client.tap do |client|
+      client.subscribe(Mongo::Monitoring::COMMAND, subscriber)
+    end
+  end
+
   let(:collection) do
-    subscribed_client['get_more_spec']
+    client['get_more_spec']
   end
 
   let(:scope) do
@@ -16,11 +24,10 @@ describe 'getMore operation' do
     collection.delete_many
     collection.insert_one(a: 1)
     #collection.insert_one(a: 2)
-    EventSubscriber.clear_events!
   end
 
   let(:get_more_command) do
-    event = EventSubscriber.single_command_started_event('getMore')
+    event = subscriber.single_command_started_event('getMore')
     event.command['getMore']
   end
 

data/spec/integration/heartbeat_events_spec.rb

@@ -62,7 +62,7 @@ describe 'Heartbeat events' do
 
   it 'notifies on failed heartbeats' do
     exc = HeartbeatEventsSpecTestException.new
-    expect_any_instance_of(Mongo::Server::Monitor::Connection).to receive(:ismaster).at_least(:once).and_raise(exc)
+    expect_any_instance_of(Mongo::Server::Monitor).to receive(:ismaster).at_least(:once).and_raise(exc)
 
     expect do
       client.database.command(ismaster: 1)

data/spec/integration/read_preference_spec.rb

@@ -77,11 +77,11 @@ describe 'Read preference' do
       it_behaves_like 'does not send read preference when reading'
     end
 
-    context 'RS, sharded cluster' do
+    context 'replica set' do
       # Supposedly read preference should only be sent in a sharded cluster
       # topology. However, transactions spec tests contain read preference
       # assertions also when they are run in RS topologies.
-      require_topology :sharded, :replica_set
+      require_topology :replica_set
 
       context 'pre-OP_MSG server' do
         max_server_version '3.4'
@@ -95,6 +95,13 @@ describe 'Read preference' do
         it_behaves_like 'sends expected read preference when reading'
       end
     end
+
+    context 'sharded cluster' do
+      # Driver does not send $readPreference document to mongos when
+      # specified mode is primary.
+      require_topology :sharded
+      it_behaves_like 'does not send read preference when reading'
+    end
   end
 
   shared_examples_for 'sends expected read preference' do
@@ -264,18 +271,41 @@ describe 'Read preference' do
     shared_examples_for 'sends expected read preference' do
       it_behaves_like 'non-transactional read preference examples'
 
-      it 'sends expected read preference when starting transaction' do
-        collection.insert_one(hello: 'world')
+      context 'on sharded cluster' do
+        require_topology :sharded
 
-        session = client.start_session(session_options)
-        session.with_transaction(tx_options) do
-          res = collection.find({}, {session: session}.merge(find_options || {})).to_a.count
-          expect(res).to eq(1)
+        it 'does not send read preference' do
+          # Driver does not send $readPreference document to mongos when
+          # specified mode is primary.
+          collection.insert_one(hello: 'world')
+
+          session = client.start_session(session_options)
+          session.with_transaction(tx_options) do
+            res = collection.find({}, {session: session}.merge(find_options || {})).to_a.count
+            expect(res).to eq(1)
+          end
+
+          event = subscriber.single_command_started_event('find')
+          actual_preference = event.command['$readPreference']
+          expect(actual_preference).to be_nil
         end
+      end
 
-        event = subscriber.single_command_started_event('find')
-        actual_preference = event.command['$readPreference']
-        expect(actual_preference).to eq(expected_read_preference)
+      context 'on replica set' do
+        require_topology :replica_set
+        it 'sends expected read preference when starting transaction' do
+          collection.insert_one(hello: 'world')
+
+          session = client.start_session(session_options)
+          session.with_transaction(tx_options) do
+            res = collection.find({}, {session: session}.merge(find_options || {})).to_a.count
+            expect(res).to eq(1)
+          end
+
+          event = subscriber.single_command_started_event('find')
+          actual_preference = event.command['$readPreference']
+          expect(actual_preference).to eq(expected_read_preference)
+        end
       end
     end
 

data/spec/integration/reconnect_spec.rb

@@ -65,9 +65,8 @@ describe 'Client after reconnect' do
     end
 
     let(:client) do
-      ClientRegistry.instance.register_local_client(
-        Mongo::Client.new(uri, SpecConfig.instance.ssl_options.merge(
-          server_selection_timeout: 3.86, logger: logger)))
+      new_local_client(uri, SpecConfig.instance.ssl_options.merge(
+        server_selection_timeout: 3.86, logger: logger))
     end
 
     let(:wait_for_discovery) do

data/spec/integration/retryable_errors_spec.rb

@@ -4,8 +4,16 @@ describe 'Failing retryable operations' do
   # Requirement for fail point
   min_server_fcv '4.0'
 
+  let(:subscriber) { EventSubscriber.new }
+
+  let(:client_options) do
+    {}
+  end
+
   let(:client) do
-    subscribed_client
+    authorized_client.with(client_options).tap do |client|
+      client.subscribe(Mongo::Monitoring::COMMAND, subscriber)
+    end
   end
 
   let(:collection) do
@@ -83,13 +91,13 @@ describe 'Failing retryable operations' do
       end
 
       let(:events) do
-        EventSubscriber.command_started_events('find')
+        subscriber.command_started_events('find')
       end
     end
 
     shared_context 'write operation' do
       let(:fail_point_command) do
-        {
+        command = {
           configureFailPoint: 'failCommand',
           mode: {times: 2},
           data: {
@@ -97,6 +105,15 @@ describe 'Failing retryable operations' do
             errorCode: 11600,
           },
         }
+
+        if ClusterConfig.instance.short_server_version >= '4.3'
+          # Server versions 4.4 and newer will add the RetryableWriteError
+          # label to all retryable errors, and the driver must not add the label
+          # if it is not already present.
+          command[:data][:errorLabels] = ['RetryableWriteError']
+        end
+
+        command
       end
 
       let(:set_fail_point) do
@@ -119,7 +136,7 @@ describe 'Failing retryable operations' do
       end
 
       let(:events) do
-        EventSubscriber.command_started_events('insert')
+        subscriber.command_started_events('insert')
       end
     end
 
@@ -132,6 +149,7 @@ describe 'Failing retryable operations' do
       end
 
       it 'publishes two events' do
+        operation_exception
 
         expect(events.length).to eq(2)
       end
@@ -146,6 +164,7 @@ describe 'Failing retryable operations' do
       end
 
       it 'publishes one event' do
+        operation_exception
 
         expect(events.length).to eq(1)
       end
@@ -208,8 +227,8 @@ describe 'Failing retryable operations' do
       context 'modern read retries' do
         require_wired_tiger_on_36
 
-        let(:client) do
-          subscribed_client.with(retry_reads: true)
+        let(:client_options) do
+          {retry_reads: true}
         end
 
         it_behaves_like 'failing retry'
@@ -217,8 +236,8 @@ describe 'Failing retryable operations' do
       end
 
       context 'legacy read retries' do
-        let(:client) do
-          subscribed_client.with(retry_reads: false, read_retry_interval: 0)
+        let(:client_options) do
+          {retry_reads: false, read_retry_interval: 0}
         end
 
         it_behaves_like 'failing retry'
@@ -227,8 +246,8 @@ describe 'Failing retryable operations' do
     end
 
     context 'when read retries are disabled' do
-      let(:client) do
-        subscribed_client.with(retry_reads: false, max_read_retries: 0)
+      let(:client_options) do
+        {retry_reads: false, max_read_retries: 0}
       end
 
       include_context 'read operation'
@@ -243,8 +262,8 @@ describe 'Failing retryable operations' do
       context 'modern write retries' do
         require_wired_tiger_on_36
 
-        let(:client) do
-          subscribed_client.with(retry_writes: true)
+        let(:client_options) do
+          {retry_writes: true}
         end
 
         it_behaves_like 'failing retry'
@@ -252,8 +271,8 @@ describe 'Failing retryable operations' do
       end
 
       context 'legacy write' do
-        let(:client) do
-          subscribed_client.with(retry_writes: false)
+        let(:client_options) do
+          {retry_writes: false}
         end
 
         it_behaves_like 'failing retry'