mongo 2.12.4 → 2.14.0.rc1

data/spec/integration/retryable_writes/shared/supports_legacy_retries.rb

@@ -0,0 +1,19 @@
+require_relative './performs_legacy_retries'
+
+module SupportsLegacyRetries
+  shared_examples 'it supports legacy retries' do
+    context 'when server does not support modern retries' do
+      before do
+        allow_any_instance_of(Mongo::Server).to receive(:retry_writes?).and_return(false)
+      end
+
+      it_behaves_like 'it performs legacy retries'
+    end
+
+    context 'when client is set to use legacy retries' do
+      let(:retry_writes) { false }
+
+      it_behaves_like 'it performs legacy retries'
+    end
+  end
+end

data/spec/integration/retryable_writes/shared/supports_modern_retries.rb

@@ -0,0 +1,25 @@
+require_relative './performs_modern_retries'
+require_relative './performs_no_retries'
+
+module SupportsModernRetries
+  shared_examples 'it supports modern retries' do
+    let(:retry_writes) { true }
+
+    context 'against a standalone server' do
+      require_topology :single
+
+      before(:all) do
+        skip 'RUBY-2171: standalone topology currently uses legacy write retries ' \
+          'by default. Standalone should NOT retry when modern retries are enabled.'
+      end
+
+      it_behaves_like 'it performs no retries'
+    end
+
+    context 'against a replica set or sharded cluster' do
+      require_topology :replica_set, :sharded
+
+      it_behaves_like 'it performs modern retries'
+    end
+  end
+end

data/spec/integration/retryable_writes/shared/supports_retries.rb

@@ -0,0 +1,16 @@
+require_relative './supports_modern_retries'
+require_relative './supports_legacy_retries'
+
+module SupportsRetries
+  shared_examples 'it supports retries' do
+    it_behaves_like 'it supports modern retries'
+    it_behaves_like 'it supports legacy retries'
+
+    context 'when retry writes is off' do
+      let(:retry_writes) { false }
+      let(:max_write_retries) { 0 }
+
+      it_behaves_like 'it performs no retries'
+    end
+  end
+end

data/spec/integration/sdam_error_handling_spec.rb

@@ -3,11 +3,27 @@ require 'spec_helper'
 describe 'SDAM error handling' do
   clean_slate_for_all
 
+  after do
+    # Close all clients after every test to avoid leaking expectations into
+    # subsequent tests because we set global assertions on sockets.
+    ClientRegistry.instance.close_all_clients
+  end
+
   # These tests operate on specific servers, and don't work in a multi
   # shard cluster where multiple servers are equally eligible
   require_no_multi_shard
 
-  let(:client) { authorized_client_without_any_retries }
+  let(:diagnostic_subscriber) { VerboseEventSubscriber.new }
+
+  let(:client) do
+    new_local_client(SpecConfig.instance.addresses,
+      SpecConfig.instance.all_test_options.merge(
+        socket_timeout: 3, connect_timeout: 3,
+        # Uncomment to print all events to stdout:
+        #sdam_proc: Utils.subscribe_all_sdam_proc(diagnostic_subscriber),
+        **Utils.disable_retries_client_options)
+    )
+  end
 
   let(:server) { client.cluster.next_primary }
 
@@ -75,7 +91,6 @@ describe 'SDAM error handling' do
 
     before do
       client.cluster.next_primary
-      stop_monitoring(client)
       # we also need a connection to the primary so that our error
       # expectations do not get triggered during handshakes which
       # have different behavior from non-handshake errors
@@ -149,6 +164,9 @@ describe 'SDAM error handling' do
     end
 
     context 'network error' do
+      # With 4.4 servers we set up two monitoring connections, hence global
+      # socket expectations get hit twice.
+      max_server_version '4.2'
 
       let(:operation) do
         expect_any_instance_of(Mongo::Socket).to receive(:read).and_raise(exception)
@@ -179,38 +197,208 @@ describe 'SDAM error handling' do
     end
   end
 
-  # These tests fail intermittently in Evergreen
-  describe 'when there is an error on monitoring connection', retry: 3 do
-    let(:client) do
-      authorized_client_without_any_retries.with(
-        connect_timeout: 1, socket_timeout: 1)
+  describe 'when there is an error during connection establishment' do
+    require_topology :single
+
+    # The push monitor creates sockets unpredictably and interferes with this
+    # test.
+    max_server_version '4.2'
+
+    # When TLS is used there are two socket classes and we can't simply
+    # mock the base Socket class.
+    require_no_tls
+
+    {
+      SystemCallError => Mongo::Error::SocketError,
+      Errno::ETIMEDOUT => Mongo::Error::SocketTimeoutError,
+    }.each do |raw_error_cls, mapped_error_cls|
+      context raw_error_cls.name do
+        let(:socket) do
+          double('mock socket').tap do |socket|
+            allow(socket).to receive(:set_encoding)
+            allow(socket).to receive(:setsockopt)
+            allow(socket).to receive(:getsockopt)
+            allow(socket).to receive(:connect)
+            allow(socket).to receive(:close)
+            socket.should receive(:write).and_raise(raw_error_cls, 'mocked failure')
+          end
+        end
+
+        it 'marks server unknown' do
+          server = client.cluster.next_primary
+          client.cluster.servers.map(&:disconnect!)
+
+          RSpec::Mocks.with_temporary_scope do
+
+            Socket.should receive(:new).with(any_args).ordered.once.and_return(socket)
+
+            lambda do
+              client.command(ping: 1)
+            end.should raise_error(mapped_error_cls, /mocked failure/)
+
+            server.should be_unknown
+          end
+        end
+
+        it 'recovers' do
+          server = client.cluster.next_primary
+          # If we do not kill the monitor, the client will recover automatically.
+
+          RSpec::Mocks.with_temporary_scope do
+
+            Socket.should receive(:new).with(any_args).ordered.once.and_return(socket)
+            Socket.should receive(:new).with(any_args).ordered.once.and_call_original
+
+            lambda do
+              client.command(ping: 1)
+            end.should raise_error(mapped_error_cls, /mocked failure/)
+
+            client.command(ping: 1)
+          end
+        end
+      end
+    end
+
+    after do
+      # Since we stopped monitoring on the client, close it.
+      ClientRegistry.instance.close_all_clients
+    end
+  end
+
+  describe 'when there is an error on monitoring connection' do
+    clean_slate_for_all
+
+    let(:subscriber) { EventSubscriber.new }
+
+    let(:set_subscribers) do
+      client.subscribe(Mongo::Monitoring::SERVER_DESCRIPTION_CHANGED, subscriber)
+      client.subscribe(Mongo::Monitoring::CONNECTION_POOL, subscriber)
     end
 
     let(:operation) do
       expect(server.monitor.connection).not_to be nil
-      expect(server.monitor.connection).to receive(:ismaster).at_least(:once).and_raise(exception)
-      server.scan_semaphore.broadcast
-      6.times do
-        sleep 0.5
-        if server.unknown?
-          break
+      set_subscribers
+      RSpec::Mocks.with_temporary_scope do
+        expect(server.monitor).to receive(:ismaster).and_raise(exception)
+        server.monitor.scan!
+      end
+      expect_server_state_change
+    end
+
+    shared_examples_for 'marks server unknown - sdam event' do
+      it 'marks server unknown' do
+        expect(server).not_to be_unknown
+
+        #subscriber.clear_events!
+        events = subscriber.select_succeeded_events(Mongo::Monitoring::Event::ServerDescriptionChanged)
+        events.should be_empty
+
+        RSpec::Mocks.with_temporary_scope do
+          operation
+
+          events = subscriber.select_succeeded_events(Mongo::Monitoring::Event::ServerDescriptionChanged)
+          events.should_not be_empty
+          event = events.detect do |event|
+            event.new_description.address == server.address &&
+            event.new_description.unknown?
+          end
+          event.should_not be_nil
         end
       end
-      expect(server).to be_unknown
     end
 
-    context 'non-timeout network error' do
-      let(:exception) { Mongo::Error::SocketError }
+    shared_examples_for 'clears connection pool - cmap event' do
+      it 'clears connection pool' do
+        #subscriber.clear_events!
+        events = subscriber.select_published_events(Mongo::Monitoring::Event::Cmap::PoolCleared)
+        events.should be_empty
+
+        RSpec::Mocks.with_temporary_scope do
+          operation
+
+          events = subscriber.select_published_events(Mongo::Monitoring::Event::Cmap::PoolCleared)
+          events.should_not be_empty
+          event = events.detect do |event|
+            event.address == server.address
+          end
+          event.should_not be_nil
+        end
+      end
+    end
 
-      it_behaves_like 'marks server unknown'
-      it_behaves_like 'clears connection pool'
+    shared_examples_for 'marks server unknown and clears connection pool' do
+=begin These tests are not reliable
+      context 'via object inspection' do
+        let(:expect_server_state_change) do
+          server.summary.should =~ /unknown/i
+          expect(server).to be_unknown
+        end
+
+        it_behaves_like 'marks server unknown'
+        it_behaves_like 'clears connection pool'
+      end
+=end
+
+      context 'via events' do
+        # When we use events we do not need to examine object state, therefore
+        # it does not matter whether the server stays unknown or gets
+        # successfully checked.
+        let(:expect_server_state_change) do
+          # nothing
+        end
+
+        it_behaves_like 'marks server unknown - sdam event'
+        it_behaves_like 'clears connection pool - cmap event'
+      end
     end
 
-    context 'network timeout' do
-      let(:exception) { Mongo::Error::SocketTimeoutError }
+    context 'via stubs' do
+      # With 4.4 servers we set up two monitoring connections, hence global
+      # socket expectations get hit twice.
+      max_server_version '4.2'
 
-      it_behaves_like 'marks server unknown'
-      it_behaves_like 'clears connection pool'
+      context 'network timeout' do
+        let(:exception) { Mongo::Error::SocketTimeoutError }
+
+        it_behaves_like 'marks server unknown and clears connection pool'
+      end
+
+      context 'non-timeout network error' do
+        let(:exception) { Mongo::Error::SocketError }
+
+        it_behaves_like 'marks server unknown and clears connection pool'
+      end
+    end
+
+    context 'non-timeout network error via fail point' do
+      require_fail_command
+
+      let(:admin_client) { client.use(:admin) }
+
+      let(:set_fail_point) do
+        admin_client.command(
+          configureFailPoint: 'failCommand',
+          mode: {times: 2},
+          data: {
+            failCommands: %w(isMaster),
+            closeConnection: true,
+          },
+        )
+      end
+
+      let(:operation) do
+        expect(server.monitor.connection).not_to be nil
+        set_subscribers
+        set_fail_point
+        server.monitor.scan!
+        expect_server_state_change
+      end
+
+      it_behaves_like 'marks server unknown and clears connection pool'
+
+      after do
+        admin_client.command(configureFailPoint: 'failCommand', mode: 'off')
+      end
     end
   end
 end

data/spec/integration/sdam_events_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe 'SDAM events' do
-  let(:subscriber) { Mongo::SDAMMonitoring::TestSubscriber.new }
+  let(:subscriber) { EventSubscriber.new }
 
   describe 'server closed event' do
     it 'is published when client is closed' do
@@ -11,11 +11,11 @@ describe 'SDAM events' do
 
       # get the client connected
       client.database.command(ismaster: 1)
-      expect(subscriber.events).to be_empty
+      expect(subscriber.succeeded_events).to be_empty
 
       client.close
 
-      expect(subscriber.events).not_to be_empty
+      expect(subscriber.succeeded_events).not_to be_empty
       event = subscriber.first_event('server_closed_event')
       expect(event).not_to be_nil
     end
@@ -29,15 +29,87 @@ describe 'SDAM events' do
 
       # get the client connected
       client.database.command(ismaster: 1)
-      expect(subscriber.events).to be_empty
+      expect(subscriber.succeeded_events).to be_empty
 
       client.close
 
-      expect(subscriber.events).not_to be_empty
+      expect(subscriber.succeeded_events).not_to be_empty
       event = subscriber.first_event('topology_closed_event')
       expect(event).not_to be_nil
 
       expect(event.topology).to eql(client.cluster.topology)
     end
   end
+
+  describe 'heartbeat event' do
+    require_topology :single
+
+    context 'pre-4.4 servers' do
+      max_server_version '4.2'
+
+      let(:client) do
+        new_local_client(SpecConfig.instance.addresses,
+          # Heartbeat interval is bound by 500 ms
+          SpecConfig.instance.test_options.merge(heartbeat_frequency: 0.5),
+        ).tap do |client|
+          client.subscribe(Mongo::Monitoring::SERVER_HEARTBEAT, subscriber)
+        end
+      end
+
+      it 'is published every heartbeat interval' do
+        client
+        sleep 4
+        client.close
+
+        started_events = subscriber.select_started_events(Mongo::Monitoring::Event::ServerHeartbeatStarted)
+        # Expect about 8 events, maybe 9 or 7
+        started_events.length.should >= 6
+        started_events.length.should <= 10
+
+        succeeded_events = subscriber.select_succeeded_events(Mongo::Monitoring::Event::ServerHeartbeatSucceeded)
+        # Since we gracefully close the client, we expect each heartbeat
+        # to complete.
+        started_events.length.should == succeeded_events.length
+      end
+    end
+
+    context '4.4+ servers' do
+      min_server_fcv '4.4'
+
+      let(:client) do
+        new_local_client(SpecConfig.instance.addresses,
+          # Heartbeat interval is bound by 500 ms
+          SpecConfig.instance.test_options.merge(heartbeat_frequency: 0.5),
+        ).tap do |client|
+          client.subscribe(Mongo::Monitoring::SERVER_HEARTBEAT, subscriber)
+        end
+      end
+
+      it 'is published up to twice every heartbeat interval' do
+        client
+        sleep 3
+        client.close
+
+        events = subscriber.select_started_events(Mongo::Monitoring::Event::ServerHeartbeatStarted)
+        # We could have up to 16 events and should have no fewer than 8 events.
+        # Whenever an awaited ismaster succeeds while the regular monitor is
+        # waiting, the regular monitor's next scan is pushed forward.
+        events.length.should >= 6
+        events.length.should <= 18
+        (started_awaited = events.select(&:awaited?)).should_not be_empty
+        (started_regular = events.reject(&:awaited?)).should_not be_empty
+
+        events = subscriber.select_succeeded_events(Mongo::Monitoring::Event::ServerHeartbeatSucceeded)
+        events.length.should >= 6
+        events.length.should <= 18
+        (succeeded_awaited = events.select(&:awaited?)).should_not be_empty
+        (succeeded_regular = events.reject(&:awaited?)).should_not be_empty
+
+        # Since we gracefully close the client, we expect each heartbeat
+        # to complete.
+        started_awaited.length.should == succeeded_awaited.length
+        started_regular.length.should == succeeded_regular.length
+      end
+    end
+  end
 end