mongo 2.11.4 → 2.12.3

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

@@ -23,9 +23,9 @@ module Mongo
     module OpMsgOrListIndexesCommand
       include PolymorphicLookup
 
-      def execute(server)
+      def execute(server, client:)
         operation = final_operation(server)
-        operation.execute(server)
+        operation.execute(server, client: client)
       end
 
       private

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

@@ -15,19 +15,83 @@
 module Mongo
   module Operation
 
-    # Shared behavior of operations that support read preference.
+    # Read preference handling for pre-OP_MSG operation implementations.
+    #
+    # This module is not used by OP_MSG operation classes (those deriving
+    # from OpMsgBase). Instead, read preference for those classes is handled
+    # in SessionsSupported module.
     #
     # @since 2.5.2
+    # @api private
     module ReadPreferenceSupported
 
       private
 
-      SLAVE_OK = :slave_ok
-
+      # Get the options for executing the operation on a particular server.
+      #
+      # @param [ Server ] server The server that the operation will be
+      #   executed on.
+      #
+      # @return [ Hash ] The options.
+      #
+      # @since 2.0.0
       def options(server)
-        update_options_for_slave_ok(super, server)
+        add_slave_ok_flag_maybe(super, server)
+      end
+
+      # Adds :slave_ok flag to options based on the read preference specified
+      # in the operation or implied by the topology that the server is a
+      # part of.
+      #
+      # @param [ Hash ] options The options calculated so far.
+      #
+      # @return [ Hash ] The new options.
+      def add_slave_ok_flag_maybe(options, server)
+        add_flag =
+          # https://github.com/mongodb/specifications/blob/master/source/server-selection/server-selection.rst#topology-type-single
+          if server.standalone?
+            # Read preference is never sent to standalones.
+            false
+          elsif server.cluster.single?
+            # In Single topology the driver forces primaryPreferred read
+            # preference mode (via the slave_ok flag, in case of old servers)
+            # so that the query is satisfied.
+            true
+          else
+            # In replica sets and sharded clusters, read preference is passed
+            # to the server if one is specified by the application, and there
+            # is no default.
+            read && read.slave_ok?
+          end
+
+        if add_flag
+          options= options.dup
+          (options[:flags] ||= []) << :slave_ok
+        end
+
+        options
       end
 
+      def command(server)
+        sel = super
+        update_selector_for_read_pref(sel, server)
+      end
+
+      # Adds $readPreference field to the command document.
+      #
+      # $readPreference is only sent when the server is a mongos,
+      # following the rules described in
+      # https://github.com/mongodb/specifications/blob/master/source/server-selection/server-selection.rst#passing-read-preference-to-mongos.
+      # The topology does not matter for figuring out whether to send
+      # $readPreference since the decision is always made based on
+      # server type.
+      #
+      # $readPreference is not sent to pre-OP_MSG replica set members.
+      #
+      # @param [ Hash ] sel Existing command document.
+      # @param [ Server ] server The server that the command is to be sent to.
+      #
+      # @return [ Hash ] New command document to send to the server.
       def update_selector_for_read_pref(sel, server)
         if read && server.mongos? && read_pref = read.to_mongos
           Mongo::Lint.validate_camel_case_read_preference(read_pref)
@@ -37,21 +101,6 @@ module Mongo
           sel
         end
       end
-
-      def update_options_for_slave_ok(opts, server)
-        if (server.cluster.single? && !server.mongos?) || (read && read.slave_ok?)
-          opts.dup.tap do |o|
-            (o[:flags] ||= []) << SLAVE_OK
-          end
-        else
-          opts
-        end
-      end
-
-      def command(server)
-        sel = super
-        update_selector_for_read_pref(sel, server)
-      end
     end
   end
 end

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

@@ -68,7 +68,7 @@ module Mongo
       #   is included in BulkWrite which does not store the session in the
       #   receiver (despite Specifiable doing so).
       #
-      # @param [ Session | nil ] Session to consider.
+      # @param [ Session | nil ] session Session to consider.
       def unpin_maybe(session)
         yield
       rescue Mongo::Error => e

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

@@ -123,9 +123,8 @@ module Mongo
         sel = selector(server).dup
         add_write_concern!(sel)
         sel[Protocol::Msg::DATABASE_IDENTIFIER] = db_name
-        unless server.standalone?
-          sel['$readPreference'] = read.to_doc if read
-        end
+
+        add_read_preference(sel, server)
 
         if server.features.sessions_enabled?
           apply_cluster_time!(sel, server)
@@ -139,6 +138,48 @@ module Mongo
         sel
       end
 
+      # Adds $readPreference field to the command document.
+      #
+      # $readPreference is only sent when the server is a mongos,
+      # following the rules described in
+      # https://github.com/mongodb/specifications/blob/master/source/server-selection/server-selection.rst#passing-read-preference-to-mongos.
+      # The topology does not matter for figuring out whether to send
+      # $readPreference since the decision is always made based on
+      # server type.
+      #
+      # $readPreference is sent to OP_MSG-grokking replica set members.
+      #
+      # @param [ Hash ] sel Existing command document which will be mutated.
+      # @param [ Server ] server The server that the command is to be sent to.
+      def add_read_preference(sel, server)
+        # https://github.com/mongodb/specifications/blob/master/source/server-selection/server-selection.rst#topology-type-single
+        if server.standalone?
+          # Read preference is never sent to standalones.
+        elsif server.cluster.single?
+          # In Single topology:
+          # - If no read preference is specified by the application, the driver
+          #   adds mode: primaryPreferred.
+          # - If a read preference is specified by the application, the driver
+          #   replaces the mode with primaryPreferred.
+          read_doc = if read
+            BSON::Document.new(read.to_doc)
+          else
+            BSON::Document.new
+          end
+          if [nil, 'primary'].include?(read_doc['mode'])
+            read_doc['mode'] = 'primaryPreferred'
+          end
+          sel['$readPreference'] = read_doc
+        else
+          # In replica sets and sharded clusters, read preference is passed
+          # to the server if one is specified by the application, and there
+          # is no default.
+          if read
+            sel['$readPreference'] = read.to_doc
+          end
+        end
+      end
+
       def apply_session_options(sel, server)
         apply_cluster_time!(sel, server)
         sel[:txnNumber] = BSON::Int64.new(txn_num) if txn_num

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

@@ -25,42 +25,49 @@ module Mongo
       # Execute the operation.
       #
       # @example
-      #   operation.execute(server)
+      #   operation.execute(server, client: nil)
       #
       # @param [ Mongo::Server ] server The server to send the operation to.
+      # @param [ Mongo::Client ] client The client that will be used to
+      #   perform auto-encryption if it is necessary to encrypt the command
+      #   being executed (optional).
       #
       # @return [ Mongo::Operation::Result ] The operation result.
       #
       # @since 2.5.2
-      def execute(server)
+      def execute(server, client:)
         validate!
-        result = if server.features.op_msg_enabled?
-            self.class::OpMsg.new(spec).execute(server)
+        op = if server.features.op_msg_enabled?
+            self.class::OpMsg.new(spec)
           elsif !acknowledged_write?
-            self.class::Legacy.new(spec).execute(server)
+            self.class::Legacy.new(spec)
           else
-            self.class::Command.new(spec).execute(server)
+            self.class::Command.new(spec)
           end
+        result = op.execute(server, client: client)
         validate_result(result, server)
       end
 
       # Execute the bulk write operation.
       #
       # @example
-      #   operation.bulk_execute(server)
+      #   operation.bulk_execute(server, client: nil)
       #
       # @param [ Mongo::Server ] server The server to send the operation to.
+      # @param [ Mongo::Client ] client The client that will be used to
+      #   perform auto-encryption if it is necessary to encrypt the command
+      #   being executed (optional).
       #
       # @return [ Mongo::Operation::Delete::BulkResult,
       #           Mongo::Operation::Insert::BulkResult,
       #           Mongo::Operation::Update::BulkResult ] The bulk result.
       #
       # @since 2.5.2
-      def bulk_execute(server)
+      def bulk_execute(server, client:)
         if server.features.op_msg_enabled?
-          self.class::OpMsg.new(spec).execute(server).bulk_result
+          self.class::OpMsg.new(spec).execute(server, client: client).bulk_result
         else
-          self.class::Command.new(spec).execute(server).bulk_result
+          self.class::Command.new(spec).execute(server, client: client).bulk_result
         end
       end
 

data/lib/mongo/operation/update/op_msg.rb

@@ -36,7 +36,7 @@ module Mongo
         end
 
         def message(server)
-          section = { type: 1, payload: { identifier: IDENTIFIER, sequence: send(IDENTIFIER) } }
+          section = Protocol::Msg::Section1.new(IDENTIFIER, send(IDENTIFIER))
           Protocol::Msg.new(flags, {}, command(server), section)
         end
       end

data/lib/mongo/protocol/bit_vector.rb

@@ -47,9 +47,10 @@ module Mongo
         # Deserializes vector by decoding the symbol according to its mask
         #
         # @param [ String ] buffer Buffer containing the vector to be deserialized.
+        # @param [ Hash ] options This method does not currently accept any options.
         #
         # @return [ Array<Symbol> ] Flags contained in the vector
-        def deserialize(buffer)
+        def deserialize(buffer, options = {})
           vector = buffer.get_int32
           flags = []
           @masks.each do |flag, mask|

data/lib/mongo/protocol/compressed.rb

@@ -60,15 +60,13 @@ module Mongo
         @request_id = message.request_id
       end
 
-      # Inflate an OP_COMRESSED message and return the original message.
-      #
-      # @example Inflate a compressed message.
-      #  message.inflate!
+      # Inflates an OP_COMRESSED message and returns the original message.
       #
       # @return [ Protocol::Message ] The inflated message.
       #
       # @since 2.5.0
-      def inflate!
+      # @api private
+      def maybe_inflate
         message = Registry.get(@original_op_code).allocate
         uncompressed_message = Zlib::Inflate.inflate(@compressed_message)
 
@@ -81,6 +79,9 @@ module Mongo
             Message.deserialize_field(message, buf, field)
           end
         end
+        if message.is_a?(Msg)
+          message.fix_after_deserialization
+        end
         message
       end
 

data/lib/mongo/protocol/insert.rb

@@ -46,8 +46,10 @@ module Mongo
       # @param options [Hash] Additional options for the insertion.
       #
       # @option options :flags [Array] The flags for the insertion message.
-      #
       #   Supported flags: +:continue_on_error+
+      # @option options [ true, false ] validating_keys Whether keys should be
+      #   validated for being valid document keys (i.e. not begin with $ and
+      #   not contain dots).
       def initialize(database, collection, documents, options = {})
         @database = database
         @namespace = "#{database}.#{collection}"

data/lib/mongo/protocol/message.rb

@@ -95,27 +95,84 @@ module Mongo
         false
       end
 
-      # Compress a message.
+      # Compress the message, if supported by the wire protocol used and if
+      # the command being sent permits compression. Otherwise returns self.
       #
       # @param [ String, Symbol ] compressor The compressor to use.
       # @param [ Integer ] zlib_compression_level The zlib compression level to use.
       #
-      # @return [ self ] Always returns self. Other message types should override this method.
+      # @return [ self ] Always returns self. Other message types should
+      #   override this method.
       #
       # @since 2.5.0
-      def compress!(compressor, zlib_compression_level = nil)
+      # @api private
+      def maybe_compress(compressor, zlib_compression_level = nil)
         self
       end
 
-      # Inflate a message.
+      # Compress the message, if the command being sent permits compression.
+      # Otherwise returns self.
       #
-      # @return [ self ] Always returns self. Other message types should override this method.
+      # @param [ String ] command_name Command name extracted from the message.
+      # @param [ String | Symbol ] compressor The compressor to use.
+      # @param [ Integer ] zlib_compression_level Zlib compression level to use.
+      #
+      # @return [ Message ] A Protocol::Compressed message or self,
+      #  depending on whether this message can be compressed.
+      #
+      # @since 2.5.0
+      private def compress_if_possible(command_name, compressor, zlib_compression_level)
+        if compressor && compression_allowed?(command_name)
+          Compressed.new(self, compressor, zlib_compression_level)
+        else
+          self
+        end
+      end
+
+      # Inflate a message if it is compressed.
+      #
+      # @return [ Protocol::Message ] Always returns self. Subclasses should
+      #   override this method as necessary.
       #
       # @since 2.5.0
-      def inflate!
+      # @api private
+      def maybe_inflate
+        self
+      end
+
+      def maybe_decrypt(client)
+        # 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.
+        self
+      end
+
+      def maybe_encrypt(server, client)
+        # Do nothing if the Message subclass has not implemented this method
         self
       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
+      end
+
       # Serializes message into bytes that can be sent on the wire
       #
       # @param buffer [String] buffer where the message should be inserted
@@ -129,13 +186,22 @@ module Mongo
 
       alias_method :to_s, :serialize
 
-      # Deserializes messages from an IO stream
+      # Deserializes messages from an IO stream.
+      #
+      # This method returns decompressed messages (i.e. if the message on the
+      # wire was OP_COMPRESSED, this method would typically return the OP_MSG
+      # message that is the result of decompression).
       #
       # @param [ Integer ] max_message_size The max message size.
       # @param [ IO ] io Stream containing a message
+      # @param [ Hash ] options
+      #
+      # @option options [ Boolean ] :deserialize_as_bson Whether to deserialize
+      #   this message using BSON types instead of native Ruby types wherever
+      #   possible.
       #
       # @return [ Message ] Instance of a Message class
-      def self.deserialize(io, max_message_size = MAX_MESSAGE_SIZE, expected_response_to = nil)
+      def self.deserialize(io, max_message_size = MAX_MESSAGE_SIZE, expected_response_to = nil, options = {})
         length, _request_id, response_to, _op_code = deserialize_header(BSON::ByteBuffer.new(io.read(16)))
 
         # Protection from potential DOS man-in-the-middle attacks. See
@@ -155,12 +221,15 @@ module Mongo
 
         message.send(:fields).each do |field|
           if field[:multi]
-            deserialize_array(message, buffer, field)
+            deserialize_array(message, buffer, field, options)
           else
-            deserialize_field(message, buffer, field)
+            deserialize_field(message, buffer, field, options)
           end
         end
-        message.inflate!
+        if message.is_a?(Msg)
+          message.fix_after_deserialization
+        end
+        message.maybe_inflate
       end
 
       # Tests for equality between two wire protocol messages
@@ -299,11 +368,16 @@ module Mongo
       # @param message [Message] Message to contain the deserialized array.
       # @param io [IO] Stream containing the array to deserialize.
       # @param field [Hash] Hash representing a field.
+      # @param options [ Hash ]
+      #
+      # @option options [ Boolean ] :deserialize_as_bson Whether to deserialize
+      #   each of the elements in this array using BSON types wherever possible.
+      #
       # @return [Message] Message with deserialized array.
-      def self.deserialize_array(message, io, field)
+      def self.deserialize_array(message, io, field, options = {})
         elements = []
         count = message.instance_variable_get(field[:multi])
-        count.times { elements << field[:type].deserialize(io) }
+        count.times { elements << field[:type].deserialize(io, options) }
         message.instance_variable_set(field[:name], elements)
       end
 
@@ -312,11 +386,16 @@ module Mongo
       # @param message [Message] Message to contain the deserialized field.
       # @param io [IO] Stream containing the field to deserialize.
       # @param field [Hash] Hash representing a field.
+      # @param options [ Hash ]
+      #
+      # @option options [ Boolean ] :deserialize_as_bson Whether to deserialize
+      #   this field using BSON types wherever possible.
+      #
       # @return [Message] Message with deserialized field.
-      def self.deserialize_field(message, io, field)
+      def self.deserialize_field(message, io, field, options = {})
         message.instance_variable_set(
           field[:name],
-          field[:type].deserialize(io)
+          field[:type].deserialize(io, options)
         )
       end