mongo 2.11.0 → 2.11.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d27047092172489df2f36b02e09050990a7aae2685a055bf4a30d33a43b86325
-  data.tar.gz: 0f14e016a1dbae9ccda55d77927a773d58a10967b959b9480b052c2df9410386
+  metadata.gz: 33db1e0c2cfe7d7de3da0fbc3b24deac1ab01c0ad3cfc07239616bda20bd3e21
+  data.tar.gz: 6923e1d8fff7313a7f1a5a73e5a23fcebc6fa9b2b3d083e7f7468928ff2d76f1
 SHA512:
-  metadata.gz: 3cf2e4bfd5860003b7131c72fae1b58a0a56906a73d67e9e08c465cd5cf0b79f99af431e55597733f3baf9d68a9617cec47647d4bb7b9c8e84eedeeff96509b9
-  data.tar.gz: 190be385cbcfdae0293448281010b8d6c4ca785b37236fe57362921eaeb7cfdb5115dd0159e51622946b97170fa105a375fd0a73ceb4600b268e599aa687dcf1
+  metadata.gz: 415ae16f9f26a04e7ed9d9d29f264f2632a8cfca230849a11152f8bc62a722aa4a7e600ca5db217e26e695ca2b270a54973bb9c339af67f1f3880c67ed917cc4
+  data.tar.gz: '058ec4695e331e142f99feee1a59082494ed91e80d55490985e8eee650f1d94ba767d581ea08180ccff18c93300642ea59ca91dc1fe44da6771fd4ca2a94d27f'

data/lib/mongo/retryable.rb

@@ -119,7 +119,12 @@ module Mongo
         legacy_read_with_retry(session, server_selector, &block)
       else
         server = select_server(cluster, server_selector, session)
-        yield server
+        begin
+          yield server
+        rescue Error::SocketError, Error::SocketTimeoutError, Error::OperationFailure => e
+          e.add_note('retries disabled')
+          raise e
+        end
       end
     end
 
@@ -214,12 +219,14 @@ module Mongo
       begin
         yield(server, txn_num, false)
       rescue Error::SocketError, Error::SocketTimeoutError => e
+        e.add_note('modern retry')
         e.add_note("attempt 1")
         if session.in_transaction? && !ending_transaction
           raise e
         end
         retry_write(e, session, txn_num, &block)
       rescue Error::OperationFailure => e
+        e.add_note('modern retry')
         e.add_note("attempt 1")
         if e.unsupported_retryable_write?
           raise_unsupported_error(e)
@@ -250,7 +257,12 @@ module Mongo
     def nro_write_with_retry(session, write_concern, &block)
       if session && session.client.options[:retry_writes]
         server = select_server(cluster, ServerSelector.primary, session)
-        yield server
+        begin
+          yield server
+        rescue Error::SocketError, Error::SocketTimeoutError, Error::OperationFailure => e
+          e.add_note('retries disabled')
+          raise e
+        end
       else
         legacy_write_with_retry(nil, session, &block)
       end
@@ -280,7 +292,8 @@ module Mongo
         server ||= select_server(cluster, ServerSelector.primary, session)
         yield server
       rescue Error::OperationFailure => e
-        e.add_note("attempt #{attempt + 1}")
+        e.add_note('legacy retry')
+        e.add_note("attempt #{attempt}")
         server = nil
         if attempt > client.max_write_retries
           raise e
@@ -298,18 +311,19 @@ module Mongo
     private
 
     def modern_read_with_retry(session, server_selector, &block)
-      attempt = 0
       server = select_server(cluster, server_selector, session)
       begin
         yield server
       rescue Error::SocketError, Error::SocketTimeoutError => e
-        e.add_note("attempt #{attempt + 1}")
+        e.add_note('modern retry')
+        e.add_note("attempt 1")
         if session.in_transaction?
           raise e
         end
         retry_read(e, server_selector, session, &block)
       rescue Error::OperationFailure => e
-        e.add_note("attempt #{attempt + 1}")
+        e.add_note('modern retry')
+        e.add_note("attempt 1")
         if session.in_transaction? || !e.write_retryable?
           raise e
         end
@@ -324,7 +338,8 @@ module Mongo
         attempt += 1
         yield server
       rescue Error::SocketError, Error::SocketTimeoutError => e
-        e.add_note("attempt #{attempt + 1}")
+        e.add_note('legacy retry')
+        e.add_note("attempt #{attempt}")
         if attempt > client.max_read_retries || (session && session.in_transaction?)
           raise e
         end
@@ -332,7 +347,8 @@ module Mongo
         server = select_server(cluster, server_selector, session)
         retry
       rescue Error::OperationFailure => e
-        e.add_note("attempt #{attempt + 1}")
+        e.add_note('legacy retry')
+        e.add_note("attempt #{attempt}")
         if e.retryable? && !(session && session.in_transaction?)
           if attempt > client.max_read_retries
             raise e
@@ -375,9 +391,11 @@ module Mongo
       begin
         yield server, true
       rescue Error::SocketError, Error::SocketTimeoutError => e
+        e.add_note('modern retry')
         e.add_note("attempt 2")
         raise e
       rescue Error::OperationFailure => e
+        e.add_note('modern retry')
         unless e.write_retryable?
           original_error.add_note("later retry failed: #{e.class}: #{e}")
           raise original_error
@@ -385,6 +403,7 @@ module Mongo
         e.add_note("attempt 2")
         raise e
       rescue => e
+        e.add_note('modern retry')
         original_error.add_note("later retry failed: #{e.class}: #{e}")
         raise original_error
       end
@@ -398,15 +417,19 @@ module Mongo
       # server unknown). Here we just need to wait for server selection.
       server = select_server(cluster, ServerSelector.primary, session)
       unless server.retry_writes?
+        # Do not need to add "modern retry" here, it should already be on
+        # the first exception.
         original_error.add_note('did not retry because server selected for retry does not supoprt retryable writes')
         raise original_error
       end
       log_retry(original_error, message: 'Write retry')
       yield(server, txn_num, true)
     rescue Error::SocketError, Error::SocketTimeoutError => e
+      e.add_note('modern retry')
       e.add_note('attempt 2')
       raise e
     rescue Error::OperationFailure => e
+      e.add_note('modern retry')
       if e.write_retryable?
         e.add_note('attempt 2')
         raise e
@@ -415,6 +438,8 @@ module Mongo
         raise original_error
       end
     rescue => e
+      # Do not need to add "modern retry" here, it should already be on
+      # the first exception.
       original_error.add_note("later retry failed: #{e.class}: #{e}")
       raise original_error
     end

data/lib/mongo/version.rb

@@ -17,5 +17,5 @@ module Mongo
   # The current version of the driver.
   #
   # @since 2.0.0
-  VERSION = '2.11.0'.freeze
+  VERSION = '2.11.1'.freeze
 end

data/spec/integration/retryable_errors_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe 'Retryable writes tests' do
+describe 'Failing retryable operations' do
   # Requirement for fail point
   min_server_fcv '4.0'
 
@@ -9,22 +9,12 @@ describe 'Retryable writes tests' do
   end
 
   let(:collection) do
-    client['retryable-writes-error-spec']
+    client['retryable-errors-spec']
   end
 
-  context 'when retry fails' do
+  context 'when operation fails' do
     require_topology :replica_set
 
-    let(:fail_point_command) do
-      {
-        configureFailPoint: 'failCommand',
-        mode: {times: 1},
-        data: {
-          failCommands: ['find'],
-          errorCode: 11600,
-        },
-      }
-    end
 
     let(:clear_fail_point_command) do
       {
@@ -40,11 +30,7 @@ describe 'Retryable writes tests' do
     end
 
     let(:collection) do
-      client['retryable-writes-error-spec', read: {mode: :secondary_preferred}]
-    end
-
-    let(:events) do
-      events = EventSubscriber.command_started_events('find')
+      client['retryable-errors-spec', read: {mode: :secondary_preferred}]
     end
 
     let(:first_server) do
@@ -59,41 +45,220 @@ describe 'Retryable writes tests' do
       end
     end
 
-    let(:perform_read) do
-      client.cluster.servers_list.each do |server|
-        server.monitor.stop!
+    shared_context 'read operation' do
+      let(:fail_point_command) do
+        {
+          configureFailPoint: 'failCommand',
+          mode: {times: 1},
+          data: {
+            failCommands: ['find'],
+            errorCode: 11600,
+          },
+        }
       end
 
-      ClusterTools.instance.direct_client_for_each_server do |client|
+      let(:set_fail_point) do
+        client.cluster.servers_list.each do |server|
+          server.monitor.stop!
+        end
+
+        ClusterTools.instance.direct_client_for_each_server do |client|
+          client.use(:admin).database.command(fail_point_command)
+        end
+      end
+
+      let(:operation_exception) do
+        set_fail_point
+
+        begin
+          collection.find(a: 1).to_a
+        rescue Mongo::Error::OperationFailure => exception
+        else
+          fail('Expected operation to fail')
+        end
+
+        puts exception.message
+
+        exception
+      end
+
+      let(:events) do
+        EventSubscriber.command_started_events('find')
+      end
+    end
+
+    shared_context 'write operation' do
+      let(:fail_point_command) do
+        {
+          configureFailPoint: 'failCommand',
+          mode: {times: 2},
+          data: {
+            failCommands: ['insert'],
+            errorCode: 11600,
+          },
+        }
+      end
+
+      let(:set_fail_point) do
         client.use(:admin).database.command(fail_point_command)
       end
 
-      begin
-        collection.find(a: 1).to_a
-      rescue Mongo::Error::OperationFailure => @exception
-      else
-        fail('Expected operation to fail')
+      let(:operation_exception) do
+        set_fail_point
+
+        begin
+          collection.insert_one(a: 1)
+        rescue Mongo::Error::OperationFailure => exception
+        else
+          fail('Expected operation to fail')
+        end
+
+        #puts exception.message
+
+        exception
+      end
+
+      let(:events) do
+        EventSubscriber.command_started_events('insert')
+      end
+    end
+
+    shared_examples_for 'failing retry' do
+
+      it 'indicates second attempt' do
+        expect(operation_exception.message).to include('attempt 2')
+        expect(operation_exception.message).not_to include('attempt 1')
+        expect(operation_exception.message).not_to include('attempt 3')
       end
 
-      puts @exception.message
+      it 'publishes two events' do
 
-      expect(events.length).to eq(2)
-      expect(events.first.address.seed).not_to eq(events.last.address.seed)
+        expect(events.length).to eq(2)
+      end
     end
 
-    it 'is reported on the server of the second attempt' do
-      perform_read
+    shared_examples_for 'failing single attempt' do
+
+      it 'does not indicate attempt' do
+        expect(operation_exception.message).not_to include('attempt 1')
+        expect(operation_exception.message).not_to include('attempt 2')
+        expect(operation_exception.message).not_to include('attempt 3')
+      end
 
-      expect(@exception.message).not_to include(first_server.address.seed)
-      expect(@exception.message).to include(second_server.address.seed)
+      it 'publishes one event' do
+
+        expect(events.length).to eq(1)
+      end
     end
 
-    it 'marks servers used in both attempts unknown' do
-      perform_read
+    shared_examples_for 'failing retry on the same server' do
+      it 'is reported on the server of the second attempt' do
+        expect(operation_exception.message).to include(second_server.address.seed)
+      end
+    end
+
+    shared_examples_for 'failing retry on a different server' do
+      it 'is reported on the server of the second attempt' do
+        expect(operation_exception.message).not_to include(first_server.address.seed)
+        expect(operation_exception.message).to include(second_server.address.seed)
+      end
 
-      expect(first_server).to be_unknown
+      it 'marks servers used in both attempts unknown' do
+        operation_exception
 
-      expect(second_server).to be_unknown
+        expect(first_server).to be_unknown
+
+        expect(second_server).to be_unknown
+      end
+
+      it 'publishes events for the different server addresses' do
+
+        expect(events.length).to eq(2)
+        expect(events.first.address.seed).not_to eq(events.last.address.seed)
+      end
+    end
+
+    shared_examples_for 'modern retry' do
+      it 'indicates modern retry' do
+        expect(operation_exception.message).to include('modern retry')
+        expect(operation_exception.message).not_to include('legacy retry')
+        expect(operation_exception.message).not_to include('retries disabled')
+      end
+    end
+
+    shared_examples_for 'legacy retry' do
+      it 'indicates legacy retry' do
+        expect(operation_exception.message).to include('legacy retry')
+        expect(operation_exception.message).not_to include('modern retry')
+        expect(operation_exception.message).not_to include('retries disabled')
+      end
+    end
+
+    shared_examples_for 'disabled retry' do
+      it 'indicates retries are disabled' do
+        expect(operation_exception.message).to include('retries disabled')
+        expect(operation_exception.message).not_to include('legacy retry')
+        expect(operation_exception.message).not_to include('modern retry')
+      end
+    end
+
+    context 'when read is retried and retry fails' do
+      include_context 'read operation'
+
+      context 'modern read retries' do
+        require_wired_tiger_on_36
+
+        let(:client) do
+          subscribed_client.with(retry_reads: true)
+        end
+
+        it_behaves_like 'failing retry'
+        it_behaves_like 'modern retry'
+      end
+
+      context 'legacy read retries' do
+        let(:client) do
+          subscribed_client.with(retry_reads: false, read_retry_interval: 0)
+        end
+
+        it_behaves_like 'failing retry'
+        it_behaves_like 'legacy retry'
+      end
+    end
+
+    context 'when read retries are disabled' do
+      let(:client) do
+        subscribed_client.with(retry_reads: false, max_read_retries: 0)
+      end
+
+      include_context 'read operation'
+
+      it_behaves_like 'failing single attempt'
+      it_behaves_like 'disabled retry'
+    end
+
+    context 'when write is retried and retry fails' do
+      include_context 'write operation'
+
+      context 'modern write retries' do
+        require_wired_tiger_on_36
+
+        let(:client) do
+          subscribed_client.with(retry_writes: true)
+        end
+
+        it_behaves_like 'failing retry'
+        it_behaves_like 'modern retry'
+      end
+
+      context 'legacy write' do
+        let(:client) do
+          subscribed_client.with(retry_writes: false)
+        end
+
+        it_behaves_like 'failing retry'
+        it_behaves_like 'legacy retry'
+      end
     end
   end
 end