mongo 2.22.0 → 2.24.0

data/lib/mongo/protocol/message.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 # Copyright (C) 2014-2020 MongoDB Inc.
 #
@@ -17,7 +16,6 @@
 
 module Mongo
   module Protocol
-
     # A base class providing functionality required by all messages in
     # the MongoDB wire protocol. It provides a minimal DSL for defining typed
     # fields to enable serialization and deserialization over the wire.
@@ -49,34 +47,34 @@ module Mongo
       # The batch size constant.
       #
       # @since 2.2.0
-      BATCH_SIZE = 'batchSize'.freeze
+      BATCH_SIZE = 'batchSize'
 
       # The collection constant.
       #
       # @since 2.2.0
-      COLLECTION = 'collection'.freeze
+      COLLECTION = 'collection'
 
       # The limit constant.
       #
       # @since 2.2.0
-      LIMIT = 'limit'.freeze
+      LIMIT = 'limit'
 
       # The ordered constant.
       #
       # @since 2.2.0
-      ORDERED = 'ordered'.freeze
+      ORDERED = 'ordered'
 
       # The q constant.
       #
       # @since 2.2.0
-      Q = 'q'.freeze
+      Q = 'q'
 
       # Default max message size of 48MB.
       #
       # @since 2.2.1
-      MAX_MESSAGE_SIZE = 50331648.freeze
+      MAX_MESSAGE_SIZE = 50_331_648
 
-      def initialize(*args) # :nodoc:
+      def initialize(*_args) # :nodoc:
         set_request_id
       end
 
@@ -109,7 +107,7 @@ module Mongo
       #
       # @since 2.5.0
       # @api private
-      def maybe_compress(compressor, zlib_compression_level = nil)
+      def maybe_compress(_compressor, _zlib_compression_level = nil)
         self
       end
 
@@ -149,8 +147,8 @@ module Mongo
       #
       # @return [ Mongo::Protocol::Msg ] The decrypted message, or the original
       #   message if decryption was not possible or necessary.
-      def maybe_decrypt(context)
-        # TODO determine if we should be decrypting data coming from pre-4.2
+      def maybe_decrypt(_context)
+        # TODO: determine if we should be decrypting data coming from pre-4.2
         # servers, potentially using legacy wire protocols. If so we need
         # to implement decryption for those wire protocols as our current
         # encryption/decryption code is OP_MSG-specific.
@@ -165,32 +163,33 @@ module Mongo
       #
       # @return [ Mongo::Protocol::Msg ] The encrypted message, or the original
       #   message if encryption was not possible or necessary.
-      def maybe_encrypt(connection, context)
+      def maybe_encrypt(_connection, _context)
         # Do nothing if the Message subclass has not implemented this method
         self
       end
 
+      # Protocol message subclasses that support the server api option should
+      # override this method to add the server api document to the message.
+      #
+      # @param [ Hash ] server_api The server api document to add to the message.
       def maybe_add_server_api(server_api)
-        raise Error::ServerApiNotSupported, "Server API parameters cannot be sent to pre-3.6 MongoDB servers. Please remove the :server_api parameter from Client options or use MongoDB 3.6 or newer"
+        raise NotImplementedError
       end
 
       private def merge_sections
         cmd = if @sections.length > 1
-          cmd = @sections.detect { |section| section[:type] == 0 }[:payload]
-          identifier = @sections.detect { |section| section[:type] == 1}[:payload][:identifier]
-          cmd.merge(identifier.to_sym =>
-            @sections.select { |section| section[:type] == 1 }.
-              map { |section| section[:payload][:sequence] }.
-              inject([]) { |arr, documents| arr + documents }
-          )
-        elsif @sections.first[:payload]
-          @sections.first[:payload]
-        else
-          @sections.first
-        end
-        if cmd.nil?
-          raise "The command should never be nil here"
-        end
+                cmd = @sections.detect { |section| section[:type] == 0 }[:payload]
+                identifier = @sections.detect { |section| section[:type] == 1 }[:payload][:identifier]
+                cmd.merge(identifier.to_sym =>
+                  @sections.select { |section| section[:type] == 1 }
+                  .sum([]) { |section| section[:payload][:sequence] })
+              elsif @sections.first[:payload]
+                @sections.first[:payload]
+              else
+                @sections.first
+              end
+        raise 'The command should never be nil here' if cmd.nil?
+
         cmd
       end
 
@@ -204,8 +203,6 @@ module Mongo
             max_bson_size + bson_overhead
           elsif max_bson_size
             max_bson_size
-          else
-            nil
           end
 
         start = buffer.length
@@ -214,7 +211,7 @@ module Mongo
         buffer.replace_int32(start, buffer.length - start)
       end
 
-      alias_method :to_s, :serialize
+      alias to_s serialize
 
       # Deserializes messages from an IO stream.
       #
@@ -236,29 +233,26 @@ module Mongo
       #
       # @api private
       def self.deserialize(io,
-        max_message_size = MAX_MESSAGE_SIZE,
-        expected_response_to = nil,
-        options = {}
-      )
+                           max_message_size = MAX_MESSAGE_SIZE,
+                           expected_response_to = nil,
+                           options = {})
         # io is usually a Mongo::Socket instance, which supports the
         # timeout option. For compatibility with whoever might call this
         # method with some other IO-like object, pass options only when they
         # are not empty.
         read_options = options.slice(:timeout, :socket_timeout)
 
-        if read_options.empty?
-          chunk = io.read(16)
-        else
-          chunk = io.read(16, **read_options)
-        end
+        chunk = if read_options.empty?
+                  io.read(16)
+                else
+                  io.read(16, **read_options)
+                end
         buf = BSON::ByteBuffer.new(chunk)
         length, _request_id, response_to, _op_code = deserialize_header(buf)
 
         # Protection from potential DOS man-in-the-middle attacks. See
         # DRIVERS-276.
-        if length > (max_message_size || MAX_MESSAGE_SIZE)
-          raise Error::MaxMessageSize.new(max_message_size)
-        end
+        raise Error::MaxMessageSize.new(max_message_size) if length > (max_message_size || MAX_MESSAGE_SIZE)
 
         # Protection against returning the response to a previous request. See
         # RUBY-1117
@@ -266,11 +260,11 @@ module Mongo
           raise Error::UnexpectedResponse.new(expected_response_to, response_to)
         end
 
-        if read_options.empty?
-          chunk = io.read(length - 16)
-        else
-          chunk = io.read(length - 16, **read_options)
-        end
+        chunk = if read_options.empty?
+                  io.read(length - 16)
+                else
+                  io.read(length - 16, **read_options)
+                end
         buf = BSON::ByteBuffer.new(chunk)
 
         message = Registry.get(_op_code).allocate
@@ -281,9 +275,7 @@ module Mongo
             deserialize_field(message, buf, field, options)
           end
         end
-        if message.is_a?(Msg)
-          message.fix_after_deserialization
-        end
+        message.fix_after_deserialization if message.is_a?(Msg)
         message.maybe_inflate
       end
 
@@ -294,13 +286,14 @@ module Mongo
       # @return [true, false] The equality of the messages.
       def ==(other)
         return false if self.class != other.class
+
         fields.all? do |field|
           name = field[:name]
           instance_variable_get(name) ==
             other.instance_variable_get(name)
         end
       end
-      alias_method :eql?, :==
+      alias eql? ==
 
       # Creates a hash from the values of the fields of a message.
       #
@@ -323,68 +316,23 @@ module Mongo
       # @return [ 0 ] This method must be overridden, otherwise, always returns 0.
       #
       # @since 2.5.0
-      def number_returned; 0; end
-
-      private
-
-      # A method for getting the fields for a message class
-      #
-      # @return [Integer] the fields for the message class
-      def fields
-        self.class.fields
+      def number_returned
+        0
       end
 
       # A class method for getting the fields for a message class
       #
       # @return [Integer] the fields for the message class
+      # @api private
       def self.fields
         @fields ||= []
       end
 
-      # Serializes message fields into a buffer
-      #
-      # @param buffer [String] buffer to receive the field
-      # @return [String] buffer with serialized field
-      def serialize_fields(buffer, max_bson_size = nil)
-        fields.each do |field|
-          value = instance_variable_get(field[:name])
-          if field[:multi]
-            value.each do |item|
-              if field[:type].respond_to?(:size_limited?)
-                field[:type].serialize(buffer, item, max_bson_size)
-              else
-                field[:type].serialize(buffer, item)
-              end
-            end
-          else
-            if field[:type].respond_to?(:size_limited?)
-              field[:type].serialize(buffer, value, max_bson_size)
-            else
-              field[:type].serialize(buffer, value)
-            end
-          end
-        end
-      end
-
-      # Serializes the header of the message consisting of 4 32bit integers
-      #
-      # The integers represent a message length placeholder (calculation of
-      # the actual length is deferred) the request id, the response to id,
-      # and the op code for the message
-      #
-      # Currently uses hardcoded 0 for request id and response to as their
-      # values are irrelevent to the server
-      #
-      # @param buffer [String] Buffer to receive the header
-      # @return [String] Serialized header
-      def serialize_header(buffer)
-        Header.serialize(buffer, [0, request_id, 0, op_code])
-      end
-
       # Deserializes the header of the message
       #
       # @param io [IO] Stream containing the header.
       # @return [Array<Fixnum>] Deserialized header.
+      # @api private
       def self.deserialize_header(io)
         Header.deserialize(io)
       end
@@ -404,11 +352,12 @@ module Mongo
       #     fields that use the number.
       #
       # @return [NilClass]
+      # @api private
       def self.field(name, type, multi = false)
         fields << {
-          :name => "@#{name}".intern,
-          :type => type,
-          :multi => multi
+          name: :"@#{name}",
+          type: type,
+          multi: multi
         }
 
         attr_reader name
@@ -429,6 +378,7 @@ module Mongo
       #   each of the elements in this array using BSON types wherever possible.
       #
       # @return [Message] Message with deserialized array.
+      # @api private
       def self.deserialize_array(message, io, field, options = {})
         elements = []
         count = message.instance_variable_get(field[:multi])
@@ -447,12 +397,60 @@ module Mongo
       #   this field using BSON types wherever possible.
       #
       # @return [Message] Message with deserialized field.
+      # @api private
       def self.deserialize_field(message, io, field, options = {})
         message.instance_variable_set(
           field[:name],
           field[:type].deserialize(io, options)
         )
       end
+
+      private
+
+      # A method for getting the fields for a message class
+      #
+      # @return [Integer] the fields for the message class
+      def fields
+        self.class.fields
+      end
+
+      # Serializes message fields into a buffer
+      #
+      # @param buffer [String] buffer to receive the field
+      # @return [String] buffer with serialized field
+      def serialize_fields(buffer, max_bson_size = nil)
+        fields.each do |field|
+          value = instance_variable_get(field[:name])
+          if field[:multi]
+            value.each do |item|
+              if field[:type].respond_to?(:size_limited?)
+                field[:type].serialize(buffer, item, max_bson_size)
+              else
+                field[:type].serialize(buffer, item)
+              end
+            end
+          elsif field[:type].respond_to?(:size_limited?)
+            field[:type].serialize(buffer, value, max_bson_size)
+          else
+            field[:type].serialize(buffer, value)
+          end
+        end
+      end
+
+      # Serializes the header of the message consisting of 4 32bit integers
+      #
+      # The integers represent a message length placeholder (calculation of
+      # the actual length is deferred) the request id, the response to id,
+      # and the op code for the message
+      #
+      # Currently uses hardcoded 0 for request id and response to as their
+      # values are irrelevant to the server
+      #
+      # @param buffer [String] Buffer to receive the header
+      # @return [String] Serialized header
+      def serialize_header(buffer)
+        Header.serialize(buffer, [ 0, request_id, 0, op_code ])
+      end
     end
   end
 end

data/lib/mongo/protocol/msg.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 # Copyright (C) 2017-2020 MongoDB Inc.
 #
@@ -17,12 +16,9 @@
 
 module Mongo
   module Protocol
-
     # MongoDB Wire protocol Msg message (OP_MSG), a bi-directional wire
     # protocol opcode.
     #
-    # OP_MSG is only available in MongoDB 3.6 (maxWireVersion >= 6) and later.
-    #
     # @api private
     #
     # @since 2.5.0
@@ -32,13 +28,13 @@ module Mongo
       # The identifier for the database name to execute the command on.
       #
       # @since 2.5.0
-      DATABASE_IDENTIFIER = '$db'.freeze
+      DATABASE_IDENTIFIER = '$db'
 
       # Keys that the driver adds to commands. These are going to be
       # moved to the end of the hash for better logging.
       #
       # @api private
-      INTERNAL_KEYS = Set.new(%w($clusterTime $db lsid signature txnNumber)).freeze
+      INTERNAL_KEYS = Set.new(%w[$clusterTime $db lsid signature txnNumber]).freeze
 
       # Creates a new OP_MSG protocol message
       #
@@ -66,9 +62,7 @@ module Mongo
       def initialize(flags, options, main_document, *sequences)
         if flags
           flags.each do |flag|
-            unless KNOWN_FLAGS.key?(flag)
-              raise ArgumentError, "Unknown flag: #{flag.inspect}"
-            end
+            raise ArgumentError, "Unknown flag: #{flag.inspect}" unless KNOWN_FLAGS.key?(flag)
           end
         end
         @flags = flags || []
@@ -76,6 +70,7 @@ module Mongo
         unless main_document.is_a?(Hash)
           raise ArgumentError, "Main document must be a Hash, given: #{main_document.class}"
         end
+
         @main_document = main_document
         sequences.each_with_index do |section, index|
           unless section.is_a?(Section1)
@@ -84,14 +79,14 @@ module Mongo
         end
         @sequences = sequences
         @sections = [
-          {type: 0, payload: @main_document}
+          { type: 0, payload: @main_document }
         ] + @sequences.map do |section|
-          {type: 1, payload: {
+          { type: 1, payload: {
             identifier: section.identifier,
             sequence: section.documents.map do |doc|
               CachingHash.new(doc)
             end,
-          }}
+          } }
         end
         @request_id = nil
         super
@@ -140,7 +135,7 @@ module Mongo
           database_name: @main_document[DATABASE_IDENTIFIER],
           command: ordered_command,
           request_id: request_id,
-          reply: @main_document,
+          reply: @main_document
         )
       end
 
@@ -182,19 +177,20 @@ module Mongo
       #
       # @api private
       def fix_after_deserialization
-        if @sections.nil?
-          raise NotImplementedError, "After deserializations @sections should have been initialized"
-        end
+        raise NotImplementedError, 'After deserializations @sections should have been initialized' if @sections.nil?
+
         if @sections.length != 1
-          raise NotImplementedError, "Deserialization must have produced exactly one section, but it produced #{sections.length} sections"
+          raise NotImplementedError,
+                "Deserialization must have produced exactly one section, but it produced #{sections.length} sections"
         end
+
         @main_document = @sections.first
         @sequences = []
-        @sections = [{type: 0, payload: @main_document}]
+        @sections = [ { type: 0, payload: @main_document } ]
       end
 
       def documents
-        [@main_document]
+        [ @main_document ]
       end
 
       # Possibly encrypt this message with libmongocrypt. Message will only be
@@ -212,24 +208,20 @@ module Mongo
       # @return [ Mongo::Protocol::Msg ] The encrypted message, or the original
       #   message if encryption was not possible or necessary.
       def maybe_encrypt(connection, context)
-        # TODO verify compression happens later, i.e. when this method runs
-        # the message is not compressed.
         if context.encrypt?
           if connection.description.max_wire_version < 8
             raise Error::CryptError.new(
-              "Cannot perform encryption against a MongoDB server older than " +
-              "4.2 (wire version less than 8). Currently connected to server " +
+              'Cannot perform encryption against a MongoDB server older than ' +
+              '4.2 (wire version less than 8). Currently connected to server ' +
               "with max wire version #{connection.description.max_wire_version}} " +
-              "(Auto-encryption requires a minimum MongoDB version of 4.2)"
+              '(Auto-encryption requires a minimum MongoDB version of 4.2)'
             )
           end
 
           db_name = @main_document[DATABASE_IDENTIFIER]
           cmd = merge_sections
           enc_cmd = context.encrypt(db_name, cmd)
-          if cmd.key?('$db') && !enc_cmd.key?('$db')
-            enc_cmd['$db'] = cmd['$db']
-          end
+          enc_cmd['$db'] = cmd['$db'] if cmd.key?('$db') && !enc_cmd.key?('$db')
 
           Msg.new(@flags, @options, enc_cmd)
         else
@@ -274,25 +266,22 @@ module Mongo
         updates = @main_document['updates']
         deletes = @main_document['deletes']
 
-        num_inserts = inserts && inserts.length || 0
-        num_updates = updates && updates.length || 0
-        num_deletes = deletes && deletes.length || 0
+        num_inserts = (inserts && inserts.length) || 0
+        num_updates = (updates && updates.length) || 0
+        num_deletes = (deletes && deletes.length) || 0
 
-        num_inserts > 1  || num_updates > 1 || num_deletes > 1
+        num_inserts > 1 || num_updates > 1 || num_deletes > 1
       end
 
       def maybe_add_server_api(server_api)
         conflicts = {}
-        %i(apiVersion apiStrict apiDeprecationErrors).each do |key|
-          if @main_document.key?(key)
-            conflicts[key] = @main_document[key]
-          end
-          if @main_document.key?(key.to_s)
-            conflicts[key] = @main_document[key.to_s]
-          end
+        %i[apiVersion apiStrict apiDeprecationErrors].each do |key|
+          conflicts[key] = @main_document[key] if @main_document.key?(key)
+          conflicts[key] = @main_document[key.to_s] if @main_document.key?(key.to_s)
         end
         unless conflicts.empty?
-          raise Error::ServerApiConflict, "The Client is configured with :server_api option but the operation provided the following conflicting parameters: #{conflicts.inspect}"
+          raise Error::ServerApiConflict,
+                "The Client is configured with :server_api option but the operation provided the following conflicting parameters: #{conflicts.inspect}"
         end
 
         main_document = @main_document.merge(
@@ -309,14 +298,11 @@ module Mongo
       #
       # @return [ Integer ] Number of returned documents.
       def number_returned
-        if doc = documents.first
-          if cursor = doc['cursor']
-            if batch = cursor['firstBatch'] || cursor['nextBatch']
-              return batch.length
-            end
-          end
+        if (doc = documents.first) && (cursor = doc['cursor']) && (batch = cursor['firstBatch'] || cursor['nextBatch'])
+          return batch.length
         end
-        raise NotImplementedError, "number_returned is only defined for cursor replies"
+
+        raise NotImplementedError, 'number_returned is only defined for cursor replies'
       end
 
       private
@@ -333,28 +319,27 @@ module Mongo
             end
         end
 
-        if contains_too_large_document
-          raise Error::MaxBSONSize.new('The document exceeds maximum allowed BSON object size after serialization')
-        end
+        return unless contains_too_large_document
+
+        raise Error::MaxBSONSize.new('The document exceeds maximum allowed BSON object size after serialization')
       end
 
       def command
         @command ||= if @main_document
-          @main_document.dup.tap do |cmd|
-            @sequences.each do |section|
-              cmd[section.identifier] ||= []
-              cmd[section.identifier] += section.documents
-            end
-          end
-        else
-          documents.first
-        end
+                       @main_document.dup.tap do |cmd|
+                         @sequences.each do |section|
+                           cmd[section.identifier] ||= []
+                           cmd[section.identifier] += section.documents
+                         end
+                       end
+                     else
+                       documents.first
+                     end
       end
 
-      def add_check_sum(buffer)
-        if flags.include?(:checksum_present)
-          #buffer.put_int32(checksum)
-        end
+      def add_check_sum(_buffer)
+        nil unless flags.include?(:checksum_present)
+        # buffer.put_int32(checksum)
       end
 
       # Encapsulates a type 1 OP_MSG section.
@@ -374,7 +359,7 @@ module Mongo
             identifier == other.identifier && documents == other.documents
         end
 
-        alias :eql? :==
+        alias eql? ==
       end
 
       # The operation code required to specify a OP_MSG message.