mongo 2.12.4 → 2.14.0.rc1

data/spec/integration/command_spec.rb

@@ -8,16 +8,18 @@ describe 'Command' do
     let(:server) { authorized_client.cluster.next_primary }
 
     let(:payload) do
-      command.send(:final_operation, server).send(:message, server).payload.dup.tap do |payload|
-        if payload['request_id'].is_a?(Integer)
-          payload['request_id'] = 42
+      server.with_connection do |connection|
+        command.send(:final_operation, connection).send(:message, connection).payload.dup.tap do |payload|
+          if payload['request_id'].is_a?(Integer)
+            payload['request_id'] = 42
+          end
+          # $clusterTime may be present depending on the client's state
+          payload['command'].delete('$clusterTime')
+          # 3.6+ servers also return a payload field, earlier ones do not.
+          # The contents of this field duplicates the rest of the response
+          # so we can get rid of it without losing information.
+          payload.delete('reply')
         end
-        # $clusterTime may be present depending on the client's state
-        payload['command'].delete('$clusterTime')
-        # 3.6+ servers also return a payload field, earlier ones do not.
-        # The contents of this field duplicates the rest of the response
-        # so we can get rid of it without losing information.
-        payload.delete('reply')
       end
     end
 

data/spec/integration/connect_single_rs_name_spec.rb

@@ -18,7 +18,9 @@ describe 'Direct connection with RS name' do
     new_local_client(
       [SpecConfig.instance.addresses.first],
       SpecConfig.instance.test_options.merge(
-        replica_set: replica_set_name, connect: :direct))
+        replica_set: replica_set_name, connect: :direct,
+        server_selection_timeout: 3.32,
+      ))
   end
 
   context 'in replica set' do
@@ -31,7 +33,8 @@ describe 'Direct connection with RS name' do
 
       it 'creates a working client' do
         expect do
-          client.database.command(ismaster: 1)
+          res = client.database.command(ismaster: 1)
+          p res
         end.not_to raise_error
       end
     end
@@ -41,10 +44,11 @@ describe 'Direct connection with RS name' do
 
       it_behaves_like 'passes RS name to topology'
 
-      it 'creates a client which raises on every operation' do
+      it 'creates a client which does not find a suitable server' do
+        # TODO When RUBY-2197 is implemented, assert the error message also
         expect do
           client.database.command(ismaster: 1)
-        end.to raise_error(Mongo::Error::NoServerAvailable, "Cluster topology specifies replica set name wrong, but the server has replica set name #{ClusterConfig.instance.replica_set_name}")
+        end.to raise_error(Mongo::Error::NoServerAvailable)
       end
     end
   end
@@ -58,9 +62,10 @@ describe 'Direct connection with RS name' do
       it_behaves_like 'passes RS name to topology'
 
       it 'creates a client which raises on every operation' do
+        # TODO When RUBY-2197 is implemented, assert the error message also
         expect do
           client.database.command(ismaster: 1)
-        end.to raise_error(Mongo::Error::NoServerAvailable, 'Cluster topology specifies replica set name any, but the server has replica set name <nil>')
+        end.to raise_error(Mongo::Error::NoServerAvailable)
       end
     end
   end

data/spec/integration/connection_pool_populator_spec.rb

@@ -4,7 +4,9 @@ describe 'Connection pool populator integration' do
   let(:options) { {} }
 
   let(:server_options) do
-    SpecConfig.instance.test_options.merge(options).merge(SpecConfig.instance.auth_options)
+    Mongo::Utils.shallow_symbolize_keys(Mongo::Client.canonicalize_ruby_options(
+      SpecConfig.instance.all_test_options,
+    )).update(options)
   end
 
   let(:address) do

data/spec/integration/connection_spec.rb

@@ -25,6 +25,9 @@ describe 'Connections' do
       # RSpec::Expectations::ExpectationNotMetError: expected Mongo::Error::SocketError, got #<NameError: undefined method `write' for class `Mongo::Socket'>
       fails_on_jruby
 
+      # 4.4 has two monitors and thus our socket mocks get hit twice
+      max_server_version '4.2'
+
       let(:exception) { Mongo::Error::SocketError }
 
       let(:error) do
@@ -43,7 +46,8 @@ describe 'Connections' do
       end
 
       context 'with sdam event subscription' do
-        let(:subscriber) { Mongo::SDAMMonitoring::TestSubscriber.new }
+
+        let(:subscriber) { EventSubscriber.new }
         let(:client) do
           ClientRegistry.instance.global_client('authorized').with(app_name: 'connection_integration').tap do |client|
             client.subscribe(Mongo::Monitoring::SERVER_OPENING, subscriber)
@@ -55,12 +59,12 @@ describe 'Connections' do
         end
 
         it 'publishes server description changed event' do
-          expect(subscriber.events).to be_empty
+          expect(subscriber.succeeded_events).to be_empty
 
           wait_for_all_servers(client.cluster)
 
           connection
-          subscriber.events.clear
+          subscriber.succeeded_events.clear
           error
 
           event = subscriber.first_event('server_description_changed_event')

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
@@ -99,13 +127,13 @@ describe 'CRUD operations' do
   describe 'upsert' do
     context 'with default write concern' do
       it 'upserts' do
-        collection.count_documents({}).should == 0
+        collection.count_documents.should == 0
 
         res = collection.find(_id: 'foo').update_one({'$set' => {foo: 'bar'}}, upsert: true)
 
         res.documents.first['upserted'].length.should == 1
 
-        collection.count_documents({}).should == 1
+        collection.count_documents.should == 1
       end
     end
 
@@ -119,7 +147,7 @@ describe 'CRUD operations' do
       end
 
       it 'upserts' do
-        unack_collection.count_documents({}).should == 0
+        unack_collection.count_documents.should == 0
 
         res = unack_collection.find(_id: 'foo').update_one({'$set' => {foo: 'bar'}}, upsert: true)
 
@@ -127,7 +155,7 @@ describe 'CRUD operations' do
         # persisted (hopefully)
         sleep 0.25
 
-        unack_collection.count_documents({}).should == 1
+        unack_collection.count_documents.should == 1
       end
     end
   end

data/spec/integration/cursor_reaping_spec.rb

@@ -5,19 +5,33 @@ 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 }
+  around(:all) do |example|
+    saved_level = Mongo::Logger.logger.level
+    Mongo::Logger.logger.level = Logger::DEBUG
+    begin
+      example.run
+    ensure
+      Mongo::Logger.logger.level = saved_level
+    end
+  end
+
+  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,46 +40,72 @@ 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
 
       expect(events).to be_empty
     end
 
+    def abandon_cursors
+      [].tap do |cursor_ids|
+        # scopes are weird, having this result in a let block
+        # makes it not garbage collected
+        10.times do
+          scope = collection.find.batch_size(2).no_cursor_timeout
+
+          # there is no API for retrieving the cursor
+          scope.each.first
+          # and keep the first cursor
+          cursor_ids << scope.instance_variable_get('@cursor').id
+        end
+      end
+    end
+
     # this let block is a kludge to avoid copy pasting all of this code
     let(:cursor_id_and_kill_event) do
       expect(Mongo::Operation::KillCursors).to receive(:new).at_least(:once).and_call_original
 
-      cursor_id = nil
+      cursor_ids = abandon_cursors
 
-      # scopes are weird, having this result in a let block
-      # makes it not garbage collected
-      2.times do
-        scope = collection.find.batch_size(2).no_cursor_timeout
-
-        # there is no API for retrieving the cursor
-        scope.each.first
-        # and keep the first cursor
-        cursor_id ||= scope.instance_variable_get('@cursor').id
+      cursor_ids.each do |cursor_id|
+        expect(cursor_id).to be_a(Integer)
+        expect(cursor_id > 0).to be true
       end
 
-      expect(cursor_id).to be_a(Integer)
-      expect(cursor_id > 0).to be true
-
       GC.start
+      sleep 1
 
       # 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|
-        event.command['killCursors'] &&
-        event.command['cursors'].map { |c| Utils.int64_value(c) }.include?(cursor_id)
+      started_event = subscriber.started_events.detect do |event|
+        event.command['killCursors']
+      end
+      started_event.should_not be nil
+
+      found_cursor_id = nil
+      started_event = subscriber.started_events.detect do |event|
+        found = false
+        if event.command['killCursors']
+          cursor_ids.each do |cursor_id|
+            if event.command['cursors'].map { |c| Utils.int64_value(c) }.include?(cursor_id)
+              found_cursor_id = cursor_id
+              found = true
+              break
+            end
+          end
+        end
+        found
+      end
+
+      if started_event.nil?
+        p subscriber.started_events
       end
 
-      expect(started_event).not_to be_nil
+      started_event.should_not 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
 
@@ -73,7 +113,7 @@ describe 'Cursor reaping' do
 
       expect(succeeded_event.reply['ok']).to eq 1
 
-      [cursor_id, succeeded_event]
+      [found_cursor_id, succeeded_event]
     end
 
     it 'is reaped' do

data/spec/integration/docs_examples_spec.rb

@@ -1,6 +1,12 @@
 require 'spec_helper'
 
 describe 'aggregation examples in Ruby' do
+  before(:all) do
+    # In sharded clusters we need to ensure the database exists before running
+    # the tests in this file.
+    ClientRegistry.instance.global_client('authorized')['_placeholder'].create
+  end
+
   let(:client) do
     authorized_client
   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