mongo 2.17.0 → 2.17.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a7fed7eef29657f665e0b2cbecaab0e60626e76aad58087ff5fd8d051d237002
-  data.tar.gz: 77e80dd97d3d60c6836b563233f23d1f505344905d87ff8afedbe31fa45b216a
+  metadata.gz: d91b7c77d8d5e9d9298baf6aae6789f164fc9f61cb58e27c5f096ccb775fe7bd
+  data.tar.gz: 6ea13c72698ac64aac21a29ee083fb483c56b51afbe9c2a1afd75ced4cefdded
 SHA512:
-  metadata.gz: 4a898c56e637b3c0597126cc207d9c70ae9f0b3533294fab7ba92f8882be72a5df44ead386e055433966b40ad7f34ef3d0a5a82ae1c9b3088d4fb2d428673ee8
-  data.tar.gz: abec048d264aee514a33c660f0ac151f169f6b764d7e85c91f626a1ecb30e2b27c9ddcf3aa404c0f3e3cc27eb8f00dfe0e223a69096755556cb4942c5be9ce3f
+  metadata.gz: 1b037dab0a527f76219b85159117c875e3b5b9a8cffe64689df71caeb344efedffa6d04a8c9232bd9a20aa1484da0b4a9690f00c126e4095931dd682328ca341
+  data.tar.gz: 0c4b32a82ebbf64d6eccbcc0356d289e913393467c640fdf1aa7d19c2cd4150fc0a924d5815f45e59ca62a85be832012b21caf524cadda666bbd07f1d187d342

data/lib/mongo/bulk_write.rb

@@ -222,7 +222,7 @@ module Mongo
     def split_execute(name, values, connection, context, operation_id, result_combiner, session, txn_num)
       execute_operation(name, values.shift(values.size / 2), connection, context, operation_id, result_combiner, session, txn_num)
 
-      txn_num = session.next_txn_num if txn_num
+      txn_num = session.next_txn_num if txn_num && !session.in_transaction?
       execute_operation(name, values, connection, context, operation_id, result_combiner, session, txn_num)
     end
 

data/lib/mongo/cluster/reapers/cursor_reaper.rb

@@ -44,6 +44,7 @@ module Mongo
         @to_kill = {}
         @active_cursor_ids = Set.new
         @mutex = Mutex.new
+        @kill_spec_queue = Queue.new
       end
 
       attr_reader :cluster
@@ -51,17 +52,10 @@ module Mongo
       # Schedule a kill cursors operation to be eventually executed.
       #
       # @param [ Cursor::KillSpec ] kill_spec The kill specification.
-      # @param [ Mongo::Server ] server The server to send the kill cursors
-      #   operation to.
       #
       # @api private
-      def schedule_kill_cursor(kill_spec, server)
-        @mutex.synchronize do
-          if @active_cursor_ids.include?(kill_spec.cursor_id)
-            @to_kill[server.address.seed] ||= Set.new
-            @to_kill[server.address.seed] << kill_spec
-          end
-        end
+      def schedule_kill_cursor(kill_spec)
+        @kill_spec_queue << kill_spec
       end
 
       # Register a cursor id as active.
@@ -110,6 +104,24 @@ module Mongo
         end
       end
 
+      # Read and decode scheduled kill cursors operations.
+      #
+      # This method mutates instance variables without locking, so is is not
+      # thread safe. Generally, it should not be called itself, this is a helper
+      # for `kill_cursor` method.
+      #
+      # @api private
+      def read_scheduled_kill_specs
+        while kill_spec = @kill_spec_queue.pop(true)
+          if @active_cursor_ids.include?(kill_spec.cursor_id)
+            @to_kill[kill_spec.server_address] ||= Set.new
+            @to_kill[kill_spec.server_address] << kill_spec
+          end
+        end
+      rescue ThreadError
+        # Empty queue, nothing to do.
+      end
+
       # Execute all pending kill cursors operations.
       #
       # @example Execute pending kill cursors operations.
@@ -122,14 +134,14 @@ module Mongo
         # TODO optimize this to batch kill cursor operations for the same
         # server/database/collection instead of killing each cursor
         # individually.
-
         loop do
-          server_address_str = nil
+          server_address = nil
 
           kill_spec = @mutex.synchronize do
+            read_scheduled_kill_specs
             # Find a server that has any cursors scheduled for destruction.
-            server_address_str, specs =
-              @to_kill.detect { |server_address_str, specs| specs.any? }
+            server_address, specs =
+              @to_kill.detect { |_, specs| specs.any? }
 
             if specs.nil?
               # All servers have empty specs, nothing to do.
@@ -168,7 +180,7 @@ module Mongo
           op = Operation::KillCursors.new(spec)
 
           server = cluster.servers.detect do |server|
-            server.address.seed == server_address_str
+            server.address == server_address
           end
 
           unless server

data/lib/mongo/collection/view/builder/map_reduce.rb

@@ -115,11 +115,14 @@ module Mongo
             end
             command.update(view_options)
             command.update(options.slice(:collation))
+
             # Read preference isn't simply passed in the command payload
-            # (it may need to be converted to wire protocol flags)
-            # so remove it here and hopefully it's handled elsewhere.
-            # If not, RUBY-2706.
-            command.delete(:read)
+            # (it may need to be converted to wire protocol flags).
+            # Ideally it should be removed here, however due to Mongoid 7
+            # using this method and requiring :read to be returned from it,
+            # we cannot do this just yet - see RUBY-2932.
+            #command.delete(:read)
+
             command.merge!(Options::Mapper.transform_documents(options, MAPPINGS))
             command
           end

data/lib/mongo/collection/view/iterable.rb

@@ -70,7 +70,7 @@ module Mongo
             # If a query with a limit is performed, the query cache will
             # re-use results from an earlier query with the same or larger
             # limit, and then impose the lower limit during iteration.
-            limit_for_cached_query = respond_to?(:limit) ? limit : nil
+            limit_for_cached_query = respond_to?(:limit) ? QueryCache.normalized_limit(limit) : nil
           end
 
           if block_given?
@@ -170,6 +170,7 @@ module Mongo
             max_time_ms: options[:max_time_ms],
             max_value: options[:max_value],
             min_value: options[:min_value],
+            no_cursor_timeout: options[:no_cursor_timeout],
             return_key: options[:return_key],
             show_disk_loc: options[:show_disk_loc],
             comment: options[:comment],

data/lib/mongo/collection/view/map_reduce.rb

@@ -250,7 +250,20 @@ module Mongo
         end
 
         def initial_query_op(session)
-          Operation::MapReduce.new(map_reduce_spec(session))
+          spec = map_reduce_spec(session)
+          # Read preference isn't simply passed in the command payload
+          # (it may need to be converted to wire protocol flags).
+          # Passing it in command payload produces errors on at least
+          # 5.0 mongoses.
+          # In the future map_reduce_command should remove :read
+          # from its return value, however we cannot do this right now
+          # due to Mongoid 7 relying on :read being returned as part of
+          # the command - see RUBY-2932.
+          # Delete :read here for now because it cannot be sent to mongos this way.
+          spec = spec.dup
+          spec[:selector] = spec[:selector].dup
+          spec[:selector].delete(:read)
+          Operation::MapReduce.new(spec)
         end
 
         def valid_server?(server)

data/lib/mongo/cursor/kill_spec.rb

@@ -25,14 +25,31 @@ module Mongo
     # @api private
     class KillSpec
 
-      def initialize(cursor_id:, coll_name:, db_name:, service_id:)
+      def initialize(cursor_id:, coll_name:, db_name:, service_id:, server_address:)
         @cursor_id = cursor_id
         @coll_name = coll_name
         @db_name = db_name
         @service_id = service_id
+        @server_address = server_address
       end
 
-      attr_reader :cursor_id, :coll_name, :db_name, :service_id
+      attr_reader :cursor_id, :coll_name, :db_name, :service_id, :server_address
+
+      def ==(other)
+        cursor_id == other.cursor_id &&
+          coll_name == other.coll_name &&
+          db_name == other.db_name &&
+          service_id == other.service_id &&
+          server_address == other.server_address
+      end
+
+      def eql?(other)
+        self.==(other)
+      end
+
+      def hash
+        [cursor_id, coll_name, db_name, service_id, server_address].compact.hash
+      end
     end
   end
 end

data/lib/mongo/cursor.rb

@@ -84,9 +84,8 @@ module Mongo
       @session = @options[:session]
       unless closed?
         register
-        ObjectSpace.define_finalizer(self, self.class.finalize(kill_spec,
+        ObjectSpace.define_finalizer(self, self.class.finalize(kill_spec(server),
           cluster,
-          server,
           @session))
       end
     end
@@ -107,12 +106,12 @@ module Mongo
     # @return [ Proc ] The Finalizer.
     #
     # @api private
-    def self.finalize(kill_spec, cluster, server, session)
+    def self.finalize(kill_spec, cluster, session)
       unless KillSpec === kill_spec
         raise ArgumentError, "First argument must be a KillSpec: #{kill_spec.inspect}"
       end
       proc do
-        cluster.schedule_kill_cursor(kill_spec, server)
+        cluster.schedule_kill_cursor(kill_spec)
         session.end_session if session && session.implicit?
       end
     end
@@ -254,7 +253,12 @@ module Mongo
     #
     # @since 2.2.0
     def batch_size
-      @view.batch_size && @view.batch_size > 0 ? @view.batch_size : limit
+      value = @view.batch_size && @view.batch_size > 0 ? @view.batch_size : limit
+      if value == 0
+        nil
+      else
+        value
+      end
     end
 
     # Is the cursor closed?
@@ -367,12 +371,13 @@ module Mongo
     end
 
     # @api private
-    def kill_spec
+    def kill_spec(server)
       KillSpec.new(
         cursor_id: id,
         coll_name: collection_name,
         db_name: database.name,
         service_id: initial_result.connection_description.service_id,
+        server_address: server.address,
       )
     end
 

data/lib/mongo/operation/shared/sessions_supported.rb

@@ -257,10 +257,14 @@ module Mongo
         super.tap do |message|
           if session = context.session
             # Serialize the message to detect client-side problems,
-            # such as invalid BSON keys. The message will be serialized again
+            # such as invalid BSON keys or too large messages.
+            # The message will be serialized again
             # later prior to being sent to the connection.
-            message.serialize(BSON::ByteBuffer.new)
-
+            buf = BSON::ByteBuffer.new
+            message.serialize(buf)
+            if buf.length > connection.max_message_size
+              raise Error::MaxMessageSize.new(connection.max_message_size)
+            end
             session.update_state!
           end
         end

data/lib/mongo/query_cache.rb

@@ -179,7 +179,8 @@ module Mongo
       #
       # @api private
       def get(**opts)
-        limit = opts[:limit]
+        limit = normalized_limit(opts[:limit])
+
         _namespace_key = namespace_key(**opts)
         _cache_key = cache_key(**opts)
 
@@ -189,7 +190,7 @@ module Mongo
         caching_cursor = namespace_hash[_cache_key]
         return nil unless caching_cursor
 
-        caching_cursor_limit = caching_cursor.view.limit
+        caching_cursor_limit = normalized_limit(caching_cursor.view.limit)
 
         # There are two scenarios in which a caching cursor could fulfill the
         # query:
@@ -199,6 +200,7 @@ module Mongo
         #
         # Otherwise, return nil because the stored cursor will not satisfy
         # the query.
+
         if limit && (caching_cursor_limit.nil? || caching_cursor_limit >= limit)
           caching_cursor
         elsif limit.nil? && caching_cursor_limit.nil?
@@ -208,6 +210,14 @@ module Mongo
         end
       end
 
+      def normalized_limit(limit)
+        return nil unless limit
+        # For the purposes of caching, a limit of 0 means no limit, as mongo treats it as such.
+        return nil if limit == 0
+        # For the purposes of caching, a negative limit is the same as as a positive limit.
+        limit.abs
+      end
+
       private
 
       def cache_key(**opts)

data/lib/mongo/server/monitor/connection.rb

@@ -227,15 +227,21 @@ module Mongo
         # @api private
         def check_document
           server_api = @app_metadata.server_api || options[:server_api]
-          if hello_ok? || server_api
-            doc = HELLO_DOC
+          doc = if hello_ok? || server_api
+            _doc = HELLO_DOC
             if server_api
-              doc = doc.merge(Utils.transform_server_api(server_api))
+              _doc = _doc.merge(Utils.transform_server_api(server_api))
             end
-            doc
+            _doc
           else
             LEGACY_HELLO_DOC
           end
+          # compressors must be set to maintain correct compression status
+          # in the server description. See RUBY-2427
+          if compressors = options[:compressors]
+            doc = doc.merge(compression: compressors)
+          end
+          doc
         end
 
         private

data/lib/mongo/version.rb

@@ -20,5 +20,5 @@ module Mongo
   # The current version of the driver.
   #
   # @since 2.0.0
-  VERSION = '2.17.0'.freeze
+  VERSION = '2.17.3'.freeze
 end

data/spec/integration/bulk_write_spec.rb

@@ -18,6 +18,22 @@ describe 'Bulk writes' do
         authorized_collection.bulk_write(operations)
       end.not_to raise_error
     end
+
+    context 'in transaction' do
+      require_transaction_support
+      min_server_version "4.4"
+
+      it 'succeeds' do
+        authorized_collection.create
+        expect do
+          authorized_collection.client.start_session do |session|
+            session.with_transaction do
+              authorized_collection.bulk_write(operations, { session: session })
+            end
+          end
+        end.not_to raise_error
+      end
+    end
   end
 
   context 'when bulk write needs to be split' do

data/spec/integration/query_cache_spec.rb

@@ -345,18 +345,69 @@ describe 'QueryCache' do
 
         it 'uses the cache' do
           results_limit_5 = authorized_collection.find.limit(5).to_a
+          results_limit_negative_5 = authorized_collection.find.limit(-5).to_a
           results_limit_3 = authorized_collection.find.limit(3).to_a
+          results_limit_negative_3 = authorized_collection.find.limit(-3).to_a
           results_no_limit = authorized_collection.find.to_a
+          results_limit_0 = authorized_collection.find.limit(0).to_a
+
+
+          expect(results_limit_5.length).to eq(5)
+          expect(results_limit_5.map { |r| r["test"] }).to eq([0, 1, 2, 3, 4])
+
+          expect(results_limit_negative_5.length).to eq(5)
+          expect(results_limit_negative_5.map { |r| r["test"] }).to eq([0, 1, 2, 3, 4])
+
+          expect(results_limit_3.length).to eq(3)
+          expect(results_limit_3.map { |r| r["test"] }).to eq([0, 1, 2])
+
+          expect(results_limit_negative_3.length).to eq(3)
+          expect(results_limit_negative_3.map { |r| r["test"] }).to eq([0, 1, 2])
+
+          expect(results_no_limit.length).to eq(10)
+          expect(results_no_limit.map { |r| r["test"] }).to eq([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
+
+          expect(results_limit_0.length).to eq(10)
+          expect(results_limit_0.map { |r| r["test"] }).to eq([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
+
+          expect(events.length).to eq(1)
+        end
+      end
+
+      context 'when the first query has a 0 limit' do
+        before do
+          authorized_collection.find.limit(0).to_a
+        end
+
+        it 'uses the cache' do
+          results_limit_5 = authorized_collection.find.limit(5).to_a
+          results_limit_negative_5 = authorized_collection.find.limit(-5).to_a
+          results_limit_3 = authorized_collection.find.limit(3).to_a
+          results_limit_negative_3 = authorized_collection.find.limit(-3).to_a
+          results_no_limit = authorized_collection.find.to_a
+          results_limit_0 = authorized_collection.find.limit(0).to_a
 
           expect(results_limit_5.length).to eq(5)
           expect(results_limit_5.map { |r| r["test"] }).to eq([0, 1, 2, 3, 4])
 
+          expect(results_limit_negative_5.length).to eq(5)
+          expect(results_limit_negative_5.map { |r| r["test"] }).to eq([0, 1, 2, 3, 4])
+
+
           expect(results_limit_3.length).to eq(3)
           expect(results_limit_3.map { |r| r["test"] }).to eq([0, 1, 2])
 
+          expect(results_limit_negative_3.length).to eq(3)
+          expect(results_limit_negative_3.map { |r| r["test"] }).to eq([0, 1, 2])
+
+
           expect(results_no_limit.length).to eq(10)
           expect(results_no_limit.map { |r| r["test"] }).to eq([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
 
+
+          expect(results_limit_0.length).to eq(10)
+          expect(results_limit_0.map { |r| r["test"] }).to eq([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
+
           expect(events.length).to eq(1)
         end
       end
@@ -391,6 +442,21 @@ describe 'QueryCache' do
           end
         end
 
+        context 'and two queries are performed with a larger negative limit' do
+          it 'uses the query cache for the third query' do
+            results1 = authorized_collection.find.limit(-3).to_a
+            results2 = authorized_collection.find.limit(-3).to_a
+
+            expect(results1.length).to eq(3)
+            expect(results1.map { |r| r["test"] }).to eq([0, 1, 2])
+
+            expect(results2.length).to eq(3)
+            expect(results2.map { |r| r["test"] }).to eq([0, 1, 2])
+
+            expect(events.length).to eq(2)
+          end
+        end
+
         context 'and the second query has a smaller limit' do
           let(:results) { authorized_collection.find.limit(1).to_a }
 
@@ -401,6 +467,99 @@ describe 'QueryCache' do
           end
         end
 
+        context 'and the second query has a smaller negative limit' do
+          let(:results) { authorized_collection.find.limit(-1).to_a }
+
+          it 'uses the cached query' do
+            expect(results.count).to eq(1)
+            expect(results.first["test"]).to eq(0)
+            expect(events.length).to eq(1)
+          end
+        end
+
+        context 'and the second query has no limit' do
+          it 'queries again' do
+            expect(authorized_collection.find.to_a.count).to eq(10)
+            expect(events.length).to eq(2)
+          end
+        end
+      end
+
+      context 'when the first query has a negative limit' do
+        before do
+          authorized_collection.find.limit(-2).to_a
+        end
+
+        context 'and the second query has a larger limit' do
+          let(:results) { authorized_collection.find.limit(3).to_a }
+
+          it 'queries again' do
+            expect(results.length).to eq(3)
+            expect(results.map { |result| result["test"] }).to eq([0, 1, 2])
+            expect(events.length).to eq(2)
+          end
+        end
+
+        context 'and the second query has a larger negative limit' do
+          let(:results) { authorized_collection.find.limit(-3).to_a }
+
+          it 'queries again' do
+            expect(results.length).to eq(3)
+            expect(results.map { |result| result["test"] }).to eq([0, 1, 2])
+            expect(events.length).to eq(2)
+          end
+        end
+
+        context 'and two queries are performed with a larger limit' do
+          it 'uses the query cache for the third query' do
+            results1 = authorized_collection.find.limit(3).to_a
+            results2 = authorized_collection.find.limit(3).to_a
+
+            expect(results1.length).to eq(3)
+            expect(results1.map { |r| r["test"] }).to eq([0, 1, 2])
+
+            expect(results2.length).to eq(3)
+            expect(results2.map { |r| r["test"] }).to eq([0, 1, 2])
+
+            expect(events.length).to eq(2)
+          end
+        end
+
+        context 'and two queries are performed with a larger negative limit' do
+          it 'uses the query cache for the third query' do
+            results1 = authorized_collection.find.limit(-3).to_a
+            results2 = authorized_collection.find.limit(-3).to_a
+
+            expect(results1.length).to eq(3)
+            expect(results1.map { |r| r["test"] }).to eq([0, 1, 2])
+
+            expect(results2.length).to eq(3)
+            expect(results2.map { |r| r["test"] }).to eq([0, 1, 2])
+
+            expect(events.length).to eq(2)
+          end
+        end
+
+        context 'and the second query has a smaller limit' do
+          let(:results) { authorized_collection.find.limit(1).to_a }
+
+          it 'uses the cached query' do
+            expect(results.count).to eq(1)
+            expect(results.first["test"]).to eq(0)
+            expect(events.length).to eq(1)
+          end
+        end
+
+        context 'and the second query has a smaller negative limit' do
+          let(:results) { authorized_collection.find.limit(-1).to_a }
+
+          it 'uses the cached query' do
+            expect(results.count).to eq(1)
+            expect(results.first["test"]).to eq(0)
+            expect(events.length).to eq(1)
+          end
+        end
+
         context 'and the second query has no limit' do
           it 'queries again' do
             expect(authorized_collection.find.to_a.count).to eq(10)

data/spec/integration/sdam_events_spec.rb

@@ -135,4 +135,44 @@ describe 'SDAM events' do
       end
     end
   end
+
+  describe 'server description changed' do
+    require_topology :single
+
+    let(:sdam_proc) do
+      Proc.new do |client|
+        client.subscribe(Mongo::Monitoring::SERVER_DESCRIPTION_CHANGED, subscriber)
+      end
+    end
+
+    let(:client) do
+      new_local_client(SpecConfig.instance.addresses,
+        # Heartbeat interval is bound by 500 ms
+        SpecConfig.instance.test_options.merge(client_options).merge(
+          heartbeat_frequency: 0.5,
+          sdam_proc: sdam_proc,
+        ),
+      )
+    end
+
+    let(:client_options) do
+      {}
+    end
+
+    it 'is not published when there are no changes in server state' do
+      client
+      sleep 6
+      client.close
+
+      events = subscriber.select_succeeded_events(Mongo::Monitoring::Event::ServerDescriptionChanged)
+
+      # In 6 seconds we should have about 10 or 12 heartbeats.
+      # We expect 1 or 2 description changes:
+      # The first one from unknown to known,
+      # The second one because server changes the fields it returns based on
+      # driver server check payload (e.g. ismaster/isWritablePrimary).
+      events.length.should >= 1
+      events.length.should <= 2
+    end
+  end
 end

data/spec/lite_spec_helper.rb

@@ -157,6 +157,13 @@ RSpec.configure do |config|
 end
 
 if SpecConfig.instance.active_support?
+  require "active_support/version"
+  if ActiveSupport.version >= Gem::Version.new(7)
+    # ActiveSupport wants us to require ALL of it all of the time.
+    # See: https://github.com/rails/rails/issues/43851,
+    # https://github.com/rails/rails/issues/43889, etc.
+    require 'active_support'
+  end
   require "active_support/time"
   require 'mongo/active_support'
 end