mongo 2.18.2 → 2.19.3

data/spec/integration/mmapv1_spec.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 require 'spec_helper'
 

data/spec/integration/mongos_pinning_spec.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 require 'spec_helper'
 

data/spec/integration/ocsp_connectivity_spec.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 require 'lite_spec_helper'
 

data/spec/integration/ocsp_verifier_cache_spec.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 require 'lite_spec_helper'
 require 'webrick'

data/spec/integration/ocsp_verifier_spec.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 require 'lite_spec_helper'
 require 'webrick'
@@ -352,7 +352,7 @@ describe Mongo::Socket::OcspVerifier do
 
     it 'verifies' do
       # TODO This test will fail if the certificate expires
-      verifier.verify.should be true
+      expect(verifier.verify).to be(true), "If atlas-ocsp certificates have expired, run spec/support/certificates/retrieve-atlas-cert to get a new ones"
     end
   end
 end

data/spec/integration/operation_failure_code_spec.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 require 'spec_helper'
 

data/spec/integration/operation_failure_message_spec.rb

@@ -1,3 +1,4 @@
+# rubocop:todo all
 require 'spec_helper'
 
 describe 'OperationFailure message' do

data/spec/integration/query_cache_spec.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 require 'spec_helper'
 
@@ -86,7 +86,6 @@ describe 'QueryCache' do
   end
 
   describe 'query with multiple batches' do
-    min_server_fcv '3.2'
 
     before do
       102.times { |i| authorized_collection.insert_one(_id: i) }
@@ -193,7 +192,7 @@ describe 'QueryCache' do
     min_server_fcv '3.6'
 
     before do
-      authorized_client['test'].drop
+      authorized_client['test', write_concern: { w: :majority }].drop
     end
 
     context 'when two queries have same read concern' do
@@ -1253,4 +1252,92 @@ describe 'QueryCache' do
       include_examples 'retrieves full result set on second iteration'
     end
   end
+
+  describe 'concurrent queries with multiple batches' do
+
+    before do
+      102.times { |i| authorized_collection.insert_one(_id: i) }
+    end
+
+    # The query cache table is stored in thread local storage, so even though
+    # we executed the same queries in the first thread (and waited for them to
+    # finish), that query is going to be executed again (only once) in the
+    # second thread.
+    it "uses separate cache tables per thread" do
+      thread1 = Thread.new do
+        Mongo::QueryCache.cache do
+          authorized_collection.find.to_a
+          authorized_collection.find.to_a
+          authorized_collection.find.to_a
+          authorized_collection.find.to_a
+        end
+      end
+      thread1.join
+      thread2 = Thread.new do
+        Mongo::QueryCache.cache do
+          authorized_collection.find.to_a
+          authorized_collection.find.to_a
+          authorized_collection.find.to_a
+          authorized_collection.find.to_a
+        end
+      end
+      thread2.join
+
+      expect(subscriber.command_started_events('find').length).to eq(2)
+      expect(subscriber.command_started_events('getMore').length).to eq(2)
+    end
+
+    it "is able to query concurrently" do
+      wait_for_first_thread = true
+      wait_for_second_thread = true
+      threads = []
+      first_thread_docs = []
+      threads << Thread.new do
+        Mongo::QueryCache.cache do
+          # 1. iterate first batch
+          authorized_collection.find.each_with_index do |doc, i|
+            # 2. verify that we're getting all of the correct documents
+            first_thread_docs << doc
+            expect(doc).to eq({ "_id" => i })
+            if i == 50
+              # 2. check that there hasn't been a getmore
+              expect(subscriber.command_started_events('getMore').length).to eq(0)
+              # 3. mark second thread ready to start
+              wait_for_first_thread = false
+              # 4. wait for second thread
+              sleep 0.1 while wait_for_second_thread
+              # 5. verify that the other thread sent a getmore
+              expect(subscriber.command_started_events('getMore').length).to eq(1)
+            end
+            # 6. finish iterating the batch
+          end
+          # 7. verify that it still caches the query
+          authorized_collection.find.to_a
+        end
+      end
+
+      threads << Thread.new do
+        Mongo::QueryCache.cache do
+          # 1. wait for the first thread to finish first batch iteration
+          sleep 0.1 while wait_for_first_thread
+          # 2. iterate the entire result set
+          authorized_collection.find.each_with_index do |doc, i|
+            # 3. verify documnents
+            expect(doc).to eq({ "_id" => i })
+          end
+          # 4. verify get more
+          expect(subscriber.command_started_events('getMore').length).to eq(1)
+          # 5. mark second thread done
+          wait_for_second_thread = false
+          # 6. verify that it still caches the query
+          authorized_collection.find.to_a
+        end
+      end
+
+      threads.map(&:join)
+      expect(first_thread_docs.length).to eq(102)
+      expect(subscriber.command_started_events('find').length).to eq(2)
+      expect(subscriber.command_started_events('getMore').length).to eq(2)
+    end
+  end
 end

data/spec/integration/query_cache_transactions_spec.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 require 'spec_helper'
 

data/spec/integration/read_concern_spec.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 require 'spec_helper'
 

data/spec/integration/read_preference_spec.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 require 'spec_helper'
 

data/spec/integration/reconnect_spec.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 require 'spec_helper'
 
@@ -51,6 +51,9 @@ describe 'Client after reconnect' do
   end
 
   context 'with min_pool_size > 0' do
+    # This test causes live threads errors in jruby in other tests.
+    fails_on_jruby
+
     let(:client) { authorized_client.with(min_pool_size: 1) }
 
     it 'recreates connection pool populator thread' do

data/spec/integration/retryable_errors_spec.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 require 'spec_helper'
 

data/spec/integration/retryable_reads_errors_spec.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+# rubocop:todo all
+
+require 'spec_helper'
+
+describe 'Retryable reads errors tests' do
+
+  let(:client) { authorized_client.with(options.merge(retry_reads: true)) }
+
+  let(:collection) do
+    client['retryable-reads-error-spec']
+  end
+
+  context "PoolClearedError retryability test" do
+    require_topology :single, :replica_set, :sharded
+    require_no_multi_mongos
+    min_server_version '4.2.9'
+
+    let(:options) { { max_pool_size: 1, heartbeat_frequency: 1000 } }
+
+    let(:failpoint) do
+      {
+          configureFailPoint: "failCommand",
+          mode: { times: 1 },
+          data: {
+              failCommands: [ "find" ],
+              errorCode: 91,
+              blockConnection: true,
+              blockTimeMS: 1000
+          }
+      }
+    end
+
+    let(:subscriber) { Mrss::EventSubscriber.new }
+
+    let(:threads) do
+      threads = []
+      threads << Thread.new do
+        expect(collection.find(x: 1).first[:x]).to eq(1)
+      end
+      threads << Thread.new do
+        expect(collection.find(x: 1).first[:x]).to eq(1)
+      end
+      threads
+    end
+
+    let(:find_events) do
+      subscriber.started_events.select { |e| e.command_name == "find" }
+    end
+
+    let(:cmap_events) do
+      subscriber.published_events
+    end
+
+    let(:event_types) do
+      [
+        Mongo::Monitoring::Event::Cmap::ConnectionCheckedOut,
+        Mongo::Monitoring::Event::Cmap::ConnectionCheckOutFailed,
+        Mongo::Monitoring::Event::Cmap::PoolCleared,
+      ]
+    end
+
+    let(:check_out_results) do
+      cmap_events.select do |e|
+        event_types.include?(e.class)
+      end
+    end
+
+    before do
+      collection.insert_one(x: 1)
+      authorized_client.use(:admin).command(failpoint)
+      client.subscribe(Mongo::Monitoring::COMMAND, subscriber)
+      client.subscribe(Mongo::Monitoring::CONNECTION_POOL, subscriber)
+    end
+
+    it "retries on PoolClearedError" do
+      # After the first find fails, the pool is paused and retry is triggered.
+      # Now, a race is started between the second find acquiring a connection,
+      # and the first retrying the read. Now, retry reads cause the cluster to
+      # be rescanned and the pool to be unpaused, allowing the second checkout
+      # to succeed (when it should fail). Therefore we want the second find's
+      # check out to win the race. This gives the check out a little head start.
+      allow_any_instance_of(Mongo::Server::ConnectionPool).to receive(:ready).and_wrap_original do |m, *args, &block|
+        ::Utils.wait_for_condition(5) do
+          # check_out_results should contain:
+          # - find1 connection check out successful
+          # - pool cleared
+          # - find2 connection check out failed
+          # We wait here for the third event to happen before we ready the pool.
+          cmap_events.select do |e|
+            event_types.include?(e.class)
+          end.length >= 3
+        end
+        m.call(*args, &block)
+      end
+      threads.map(&:join)
+      expect(check_out_results[0]).to be_a(Mongo::Monitoring::Event::Cmap::ConnectionCheckedOut)
+      expect(check_out_results[1]).to be_a(Mongo::Monitoring::Event::Cmap::PoolCleared)
+      expect(check_out_results[2]).to be_a(Mongo::Monitoring::Event::Cmap::ConnectionCheckOutFailed)
+      expect(find_events.length).to eq(3)
+    end
+
+    after do
+      authorized_client.use(:admin).command({
+        configureFailPoint: "failCommand",
+        mode: "off",
+      })
+    end
+  end
+end

data/spec/integration/retryable_writes/retryable_writes_36_and_older_spec.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 require 'spec_helper'
 

data/spec/integration/retryable_writes/retryable_writes_40_and_newer_spec.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 require 'spec_helper'
 

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

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 module AddsDiagnostics
   shared_examples 'it adds diagnostics' do

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

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 require_relative './performs_no_retries'
 

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

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 require_relative './performs_no_retries'
 require_relative './performs_legacy_retries'

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

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 require_relative './adds_diagnostics'
 

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

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 require_relative './adds_diagnostics'
 

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

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 module PerformsNoRetries
   shared_examples 'it performs no retries' do

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

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 require_relative './performs_legacy_retries'
 

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

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 require_relative './performs_modern_retries'
 require_relative './performs_no_retries'

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

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 require_relative './supports_modern_retries'
 require_relative './supports_legacy_retries'

data/spec/integration/retryable_writes_errors_spec.rb

@@ -1,12 +1,14 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 require 'spec_helper'
 
 describe 'Retryable writes errors tests' do
 
+  let(:options) { {} }
+
   let(:client) do
-    authorized_client.with(retry_writes: true)
+    authorized_client.with(options.merge(retry_writes: true))
   end
 
   let(:collection) do
@@ -31,4 +33,160 @@ describe 'Retryable writes errors tests' do
       end
     end
   end
+
+  context "when encountering a NoWritesPerformed error after an error with a RetryableWriteError label" do
+    require_topology :replica_set
+    require_retry_writes
+    min_server_version '4.4'
+
+    let(:failpoint1) do
+      {
+        configureFailPoint: "failCommand",
+        mode: { times: 1 },
+        data: {
+          writeConcernError: {
+            code: 91,
+            errorLabels: ["RetryableWriteError"],
+          },
+          failCommands: ["insert"],
+        }
+      }
+    end
+
+    let(:failpoint2) do
+      {
+        configureFailPoint: "failCommand",
+        mode: { times: 1 },
+        data: {
+          errorCode: 10107,
+          errorLabels: ["RetryableWriteError", "NoWritesPerformed"],
+          failCommands: ["insert"],
+        },
+      }
+    end
+
+    let(:subscriber) { Mrss::EventSubscriber.new }
+
+    before do
+      authorized_client.subscribe(Mongo::Monitoring::COMMAND, subscriber)
+      authorized_client.use(:admin).command(failpoint1)
+
+      expect(authorized_collection.write_worker).to receive(:retry_write).once.and_wrap_original do |m, *args, **kwargs, &block|
+        expect(args.first.code).to eq(91)
+        authorized_client.use(:admin).command(failpoint2)
+        m.call(*args, **kwargs, &block)
+      end
+    end
+
+    after do
+      authorized_client.use(:admin).command({
+        configureFailPoint: "failCommand",
+        mode: "off",
+      })
+    end
+
+    it "returns the original error" do
+      expect do
+        authorized_collection.insert_one(x: 1)
+      end.to raise_error(Mongo::Error::OperationFailure, /\[91\]/)
+    end
+  end
+
+  context "PoolClearedError retryability test" do
+    require_topology :single, :replica_set, :sharded
+    require_no_multi_mongos
+    require_fail_command
+    require_retry_writes
+
+    let(:options) { { max_pool_size: 1 } }
+
+    let(:failpoint) do
+      {
+          configureFailPoint: "failCommand",
+          mode: { times: 1 },
+          data: {
+              failCommands: [ "insert" ],
+              errorCode: 91,
+              blockConnection: true,
+              blockTimeMS: 1000,
+              errorLabels: ["RetryableWriteError"]
+          }
+      }
+    end
+
+    let(:subscriber) { Mrss::EventSubscriber.new }
+
+    let(:threads) do
+      threads = []
+      threads << Thread.new do
+        expect(collection.insert_one(x: 2)).to be_successful
+      end
+      threads << Thread.new do
+        expect(collection.insert_one(x: 2)).to be_successful
+      end
+      threads
+    end
+
+    let(:insert_events) do
+      subscriber.started_events.select { |e| e.command_name == "insert" }
+    end
+
+    let(:cmap_events) do
+      subscriber.published_events
+    end
+
+    let(:event_types) do
+      [
+        Mongo::Monitoring::Event::Cmap::ConnectionCheckedOut,
+        Mongo::Monitoring::Event::Cmap::ConnectionCheckOutFailed,
+        Mongo::Monitoring::Event::Cmap::PoolCleared,
+      ]
+    end
+
+    let(:check_out_results) do
+      cmap_events.select do |e|
+        event_types.include?(e.class)
+      end
+    end
+
+    before do
+      authorized_client.use(:admin).command(failpoint)
+      client.subscribe(Mongo::Monitoring::COMMAND, subscriber)
+      client.subscribe(Mongo::Monitoring::CONNECTION_POOL, subscriber)
+    end
+
+    it "retries on PoolClearedError" do
+      # After the first insert fails, the pool is paused and retry is triggered.
+      # Now, a race is started between the second insert acquiring a connection,
+      # and the first retrying the read. Now, retry reads cause the cluster to
+      # be rescanned and the pool to be unpaused, allowing the second checkout
+      # to succeed (when it should fail). Therefore we want the second insert's
+      # check out to win the race. This gives the check out a little head start.
+      allow_any_instance_of(Mongo::Server::ConnectionPool).to receive(:ready).and_wrap_original do |m, *args, &block|
+        ::Utils.wait_for_condition(5) do
+          # check_out_results should contain:
+          # - insert1 connection check out successful
+          # - pool cleared
+          # - insert2 connection check out failed
+          # We wait here for the third event to happen before we ready the pool.
+          cmap_events.select do |e|
+            event_types.include?(e.class)
+          end.length >= 3
+        end
+        m.call(*args, &block)
+      end
+      threads.map(&:join)
+      expect(check_out_results[0]).to be_a(Mongo::Monitoring::Event::Cmap::ConnectionCheckedOut)
+      expect(check_out_results[1]).to be_a(Mongo::Monitoring::Event::Cmap::PoolCleared)
+      expect(check_out_results[2]).to be_a(Mongo::Monitoring::Event::Cmap::ConnectionCheckOutFailed)
+      expect(insert_events.length).to eq(3)
+    end
+
+    after do
+      authorized_client.use(:admin).command({
+        configureFailPoint: "failCommand",
+        mode: "off",
+      })
+    end
+  end
 end