RUBY-2345 Validate that documents don't exceed maxBsonObjectSize on servers older than 3.6 (#2055)

Author: Emily Giurleo

lib/mongo/protocol/message.rb

@@ -177,10 +177,19 @@ def maybe_encrypt(server, client)
       #
       # @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
 

lib/mongo/protocol/msg.rb

@@ -139,7 +139,7 @@ def payload
       # @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

lib/mongo/protocol/query.rb

@@ -115,12 +115,48 @@ def maybe_compress(compressor, zlib_compression_level = nil)
         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.
       #

lib/mongo/server/connection_base.rb

@@ -189,10 +189,8 @@ def serialize(message, client, buffer = BSON::ByteBuffer.new)
           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 @@ def serialize(message, client, buffer = BSON::ByteBuffer.new)
           # 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 @@ def serialize(message, client, buffer = BSON::ByteBuffer.new)
         # 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

spec/integration/client_side_encryption/auto_encryption_bulk_writes_spec.rb

@@ -162,15 +162,19 @@
       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

spec/integration/size_limit_spec.rb

@@ -62,30 +62,31 @@
     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