mongo 2.12.3 → 2.12.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d246db379228f5a887c2fdc21098808da28bcfba008dd6d3218475c6d00b112e
-  data.tar.gz: 34be39488f7ce9de6746e03db0524d80815c12bcd384a488734572576f491eec
+  metadata.gz: c810c7a786a9400b9a55c53b59a8078ec63e57703e8cf564e5001188cd33144b
+  data.tar.gz: 2230cea6d335950d790fb19f414113f7115241ce105d228f7e42a06606795b5e
 SHA512:
-  metadata.gz: 1998d33cea6ea9d43e473075b737452c5dff52d0fc7af2ef02b50fa7a56e741f26161bb475e89bba1a4fdfadd31c863b337a9c8dd26bfd5d4a21ccf43a741f7d
-  data.tar.gz: 42aa2fc57a621849a814e2fec41a7e982927303caa4199892b970289c38a620995764c76c6848090c1d74d7af56b1b1f9c99ce12f9de44a05b3255bf510b6f3a
+  metadata.gz: 1c0fd06e7e5e937ddb6a2c27f98574e79cf39e71f10a41b874186478708db34bcc6c9fa0a2cf5d191bf57ef35c613fbc40a47b8fca3ee660bd7e92dbb4f4b956
+  data.tar.gz: 28f1e23f087f9944ba3f236d78621e48b7fe91b7c75b57e9eac44d67dbe0f345c19d6be2ec96700e36de4952126fe42997702bd018eda9a70e2c25701991853a

data/lib/mongo/client.rb

@@ -446,7 +446,18 @@ module Mongo
       # construction
       sdam_proc = options.delete(:sdam_proc)
 
-      options = default_options(options).merge(options)
+      # For gssapi service_name, the default option is given in a hash
+      # (one level down from the top level).
+      merged_options = default_options(options)
+      options.each do |k, v|
+        default_v = merged_options[k]
+        if Hash === default_v
+          v = default_v.merge(v)
+        end
+        merged_options[k] = v
+      end
+      options = merged_options
+
       @options = validate_new_options!(options)
 =begin WriteConcern object support
       if @options[:write_concern].is_a?(WriteConcern::Base)
@@ -605,7 +616,7 @@ module Mongo
     #
     # @return [ BSON::Document ] The user-defined read preference.
     #   The document may have the following fields:
-    #   - *:read* -- read preference specified as a symbol; valid values are
+    #   - *:mode* -- read preference specified as a symbol; valid values are
     #     *:primary*, *:primary_preferred*, *:secondary*, *:secondary_preferred*
     #     and *:nearest*.
     #   - *:tag_sets* -- an array of hashes.

data/lib/mongo/collection.rb

@@ -278,8 +278,12 @@ module Mongo
                               }).execute(next_primary(nil, session), client: client)
       end
     rescue Error::OperationFailure => ex
-      raise ex unless ex.message =~ /ns not found/
-      false
+      # NamespaceNotFound
+      if ex.code == 26 || ex.code.nil? && ex.message =~ /ns not found/
+        false
+      else
+        raise
+      end
     end
 
     # Find documents in the collection.

data/lib/mongo/error/operation_failure.rb

@@ -89,7 +89,8 @@ module Mongo
       # @since 2.1.1
       # @deprecated
       def retryable?
-        write_retryable? || RETRY_MESSAGES.any?{ |m| message.include?(m) }
+        write_retryable? ||
+        code.nil? && RETRY_MESSAGES.any?{ |m| message.include?(m) }
       end
 
       # Whether the error is a retryable error according to the modern retryable
@@ -102,11 +103,11 @@ module Mongo
       #
       # @since 2.4.2
       def write_retryable?
-        WRITE_RETRY_MESSAGES.any? { |m| message.include?(m) } ||
-        write_retryable_code?
+        write_retryable_code? ||
+        code.nil? && WRITE_RETRY_MESSAGES.any? { |m| message.include?(m) }
       end
 
-      def write_retryable_code?
+      private def write_retryable_code?
         if code
           WRITE_RETRY_ERRORS.any? { |e| e[:code] == code }
         else
@@ -114,7 +115,6 @@ module Mongo
           false
         end
       end
-      private :write_retryable_code?
 
       # Error codes and code names that should result in a failing getMore
       # command on a change stream NOT being resumed.

data/lib/mongo/protocol/message.rb

@@ -177,10 +177,19 @@ module Mongo
       #
       # @param buffer [String] buffer where the message should be inserted
       # @return [String] buffer containing the serialized message
-      def serialize(buffer = BSON::ByteBuffer.new, max_bson_size = nil)
+      def serialize(buffer = BSON::ByteBuffer.new, max_bson_size = nil, bson_overhead = nil)
+        max_size =
+          if max_bson_size && bson_overhead
+            max_bson_size + bson_overhead
+          elsif max_bson_size
+            max_bson_size
+          else
+            nil
+          end
+
         start = buffer.length
         serialize_header(buffer)
-        serialize_fields(buffer, max_bson_size)
+        serialize_fields(buffer, max_size)
         buffer.replace_int32(start, buffer.length - start)
       end
 

data/lib/mongo/protocol/msg.rb

@@ -139,7 +139,7 @@ module Mongo
       # @return [ BSON::ByteBuffer ] buffer containing the serialized message.
       #
       # @since 2.5.0
-      def serialize(buffer = BSON::ByteBuffer.new, max_bson_size = nil)
+      def serialize(buffer = BSON::ByteBuffer.new, max_bson_size = nil, bson_overhead = nil)
         validate_document_size!(max_bson_size)
 
         super

data/lib/mongo/protocol/query.rb

@@ -115,12 +115,48 @@ module Mongo
         compress_if_possible(selector.keys.first, compressor, zlib_compression_level)
       end
 
+      # Serializes message into bytes that can be sent on the wire.
+      #
+      # @param [ BSON::ByteBuffer ] buffer where the message should be inserted.
+      # @param [ Integer ] max_bson_size The maximum bson object size.
+      #
+      # @return [ BSON::ByteBuffer ] buffer containing the serialized message.
+      def serialize(buffer = BSON::ByteBuffer.new, max_bson_size = nil, bson_overhead = nil)
+        validate_document_size!(max_bson_size)
+
+        super
+      end
+
       protected
 
       attr_reader :upconverter
 
       private
 
+      # Validate that the documents in this message are all smaller than the
+      # maxBsonObjectSize. If not, raise an exception.
+      def validate_document_size!(max_bson_size)
+        max_bson_size ||= Mongo::Server::ConnectionBase::DEFAULT_MAX_BSON_OBJECT_SIZE
+
+        documents = if @selector.key?(:documents)
+                      @selector[:documents]
+                    elsif @selector.key?(:deletes)
+                      @selector[:deletes]
+                    elsif @selector.key?(:updates)
+                      @selector[:updates]
+                    else
+                      []
+                    end
+
+        contains_too_large_document = documents.any? do |doc|
+          doc.to_bson.length > max_bson_size
+        end
+
+        if contains_too_large_document
+          raise Error::MaxBSONSize.new('The document exceeds maximum allowed BSON object size after serialization')
+        end
+      end
+
       # The operation code required to specify a Query message.
       # @return [Fixnum] the operation code.
       #

data/lib/mongo/server/connection_base.rb

@@ -189,10 +189,8 @@ module Mongo
           if message.bulk_write?
             # Make the new maximum size equal to the specified reduced size
             # limit plus the 16KiB overhead allowance.
-            max_bson_size = REDUCED_MAX_BSON_SIZE + MAX_BSON_COMMAND_OVERHEAD
+            max_bson_size = REDUCED_MAX_BSON_SIZE
           end
-        else
-          max_bson_size += MAX_BSON_COMMAND_OVERHEAD
         end
 
         # RUBY-2234: It is necessary to check that the message size does not
@@ -217,7 +215,7 @@ module Mongo
           # TODO: address the fact that this line mutates the buffer.
           temp_buffer.put_bytes(buffer.get_bytes(buffer.length))
 
-          message.serialize(temp_buffer, max_bson_size)
+          message.serialize(temp_buffer, max_bson_size, MAX_BSON_COMMAND_OVERHEAD)
           if temp_buffer.length > max_message_size
             raise Error::MaxMessageSize.new(max_message_size)
           end
@@ -228,7 +226,7 @@ module Mongo
         # layer should be refactored to allow compression on an already-
         # serialized message.
         final_message = message.maybe_compress(compressor, options[:zlib_compression_level])
-        final_message.serialize(buffer, max_bson_size)
+        final_message.serialize(buffer, max_bson_size, MAX_BSON_COMMAND_OVERHEAD)
 
         buffer
       end

data/lib/mongo/version.rb

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

data/spec/integration/client_authentication_options_spec.rb

@@ -256,6 +256,43 @@ describe 'Client authentication options' do
         expect(client.options[:auth_mech_properties]).to eq({ 'service_name' => 'mongodb' })
       end
     end
+
+    context 'when properties are given but not service name' do
+      context 'with URI options' do
+        let(:credentials) { "#{user}:#{pwd}@" }
+
+        context 'with default auth mech properties' do
+          let(:options) { '?authMechanism=GSSAPI&authMechanismProperties=service_realm:foo' }
+
+          it 'sets service name to mongodb' do
+            expect(client.options[:auth_mech_properties]).to eq(
+              'service_name' => 'mongodb',
+              'service_realm' => 'foo',
+            )
+          end
+        end
+      end
+
+      context 'with client options' do
+        let(:client_opts) do
+          {
+            auth_mech: :gssapi,
+            user: user,
+            password: pwd,
+            auth_mech_properties: {
+              service_realm: 'foo',
+            }.freeze,
+          }.freeze
+        end
+
+        it 'sets default auth mech properties' do
+          expect(client.options[:auth_mech_properties]).to eq(
+            'service_name' => 'mongodb',
+            'service_realm' => 'foo',
+          )
+        end
+      end
+    end
   end
 
   context 'with PLAIN auth mechanism' do

data/spec/integration/client_side_encryption/auto_encryption_bulk_writes_spec.rb

@@ -162,15 +162,19 @@ describe 'Bulk writes with auto-encryption enabled' do
       context 'when one operation is larger than 16MiB' do
         let(:requests) do
           [
-            { update_one: { filter: { _id: 1 }, update: { ssn: 'a' * (Mongo::Server::ConnectionBase::DEFAULT_MAX_BSON_OBJECT_SIZE - 100) } } },
+            { update_one: { filter: { _id: 1 }, update: { ssn: 'a' * (Mongo::Server::ConnectionBase::DEFAULT_MAX_BSON_OBJECT_SIZE) } } },
             { update_one: { filter: { _id: 2 }, update: { ssn: 'a' * size_limit } } },
           ]
         end
 
+        before do
+          expect(requests.first.to_bson.length).to be > Mongo::Server::ConnectionBase::DEFAULT_MAX_BSON_OBJECT_SIZE
+        end
+
         it 'raises an exception' do
           expect do
             bulk_write.execute
-          end.to raise_error(Mongo::Error::MaxBSONSize, /maximum allowed size: 16777216 bytes/)
+          end.to raise_error(Mongo::Error::MaxBSONSize, /The document exceeds maximum allowed BSON object size after serialization/)
         end
       end
     end

data/spec/integration/size_limit_spec.rb

@@ -62,30 +62,31 @@ describe 'BSON & command size limits' do
     authorized_collection.insert_one(document)
   end
 
-  context 'on server versions >= 3.6' do
-    min_server_fcv '3.6'
+  it 'fails on the driver when a document larger than 16MiB is inserted' do
+    document = { key: 'a' * (max_document_size - 27), _id: 'foo' }
+    expect(document.to_bson.length).to eq(max_document_size+1)
 
-    it 'fails on the driver when a document larger than 16MiB is inserted' do
-      document = { key: 'a' * (max_document_size - 27), _id: 'foo' }
-      expect(document.to_bson.length).to eq(max_document_size+1)
-
-      lambda do
-        authorized_collection.insert_one(document)
-      end.should raise_error(Mongo::Error::MaxBSONSize, /The document exceeds maximum allowed BSON object size after serialization/)
-    end
+    lambda do
+      authorized_collection.insert_one(document)
+    end.should raise_error(Mongo::Error::MaxBSONSize, /The document exceeds maximum allowed BSON object size after serialization/)
   end
 
-  context 'on server versions <= 3.4' do
-    max_server_fcv '3.4'
+  it 'fails on the driver when an update larger than 16MiB is performed' do
+    document = { key: 'a' * (max_document_size - 14) }
+    expect(document.to_bson.length).to eq(max_document_size+1)
+
+    lambda do
+      authorized_collection.update_one({ _id: 'foo' }, document)
+    end.should raise_error(Mongo::Error::MaxBSONSize, /The document exceeds maximum allowed BSON object size after serialization/)
+  end
 
-    it 'fails on the server when a document larger than 16MiB is inserted' do
-      document = { key: 'a' * (max_document_size - 27), _id: 'foo' }
-      expect(document.to_bson.length).to eq(max_document_size+1)
+  it 'fails on the driver when an delete larger than 16MiB is performed' do
+    document = { key: 'a' * (max_document_size - 14) }
+    expect(document.to_bson.length).to eq(max_document_size+1)
 
-      lambda do
-        authorized_collection.insert_one(document)
-      end.should raise_error(Mongo::Error::OperationFailure, /object to insert too large/)
-    end
+    lambda do
+      authorized_collection.delete_one(document)
+    end.should raise_error(Mongo::Error::MaxBSONSize, /The document exceeds maximum allowed BSON object size after serialization/)
   end
 
   it 'fails in the driver when a document larger than 16MiB+16KiB is inserted' do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mongo
 version: !ruby/object:Gem::Version
-  version: 2.12.3
+  version: 2.12.4
 platform: ruby
 authors:
 - Tyler Brock
@@ -31,7 +31,7 @@ cert_chain:
   gpvfPNWMwyBDlHaNS3GfO6cRRxBOvEG05GUCsvtTY4Bpe8yjE64wg1ymb47LMOnv
   Qb1lGORmf/opg45mluKUYl7pQNZHD0d3
   -----END CERTIFICATE-----
-date: 2020-07-30 00:00:00.000000000 Z
+date: 2020-10-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bson