mongo 2.12.0.rc0 → 2.12.1

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/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/message.rb

@@ -194,9 +194,14 @@ module Mongo
       #
       # @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
@@ -216,9 +221,9 @@ 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
         if message.is_a?(Msg)
@@ -363,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
 
@@ -376,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
 

data/lib/mongo/protocol/msg.rb

@@ -161,7 +161,7 @@ module Mongo
       end
 
       # Reverse-populates the instance variables after deserialization sets
-      # @sections to the list of documents.
+      # the @sections instance variable to the list of documents.
       #
       # TODO fix deserialization so that this method is not needed.
       #
@@ -214,10 +214,7 @@ module Mongo
           if cmd.key?('$db') && !enc_cmd.key?('$db')
             enc_cmd['$db'] = cmd['$db']
           end
-          # This will be investigtated in RUBY-2119
-          if enc_cmd['txnNumber'].is_a?(Integer) && cmd[:txnNumber].is_a?(BSON::Int64)
-            enc_cmd['txnNumber'] = BSON::Int64.new(enc_cmd[:txnNumber])
-          end
+
           Msg.new(@flags, @options, enc_cmd)
         else
           self

data/lib/mongo/protocol/serializers.rb

@@ -57,10 +57,11 @@ module Mongo
         # Deserializes the header value from the IO stream
         #
         # @param [ String ] buffer Buffer containing the message header.
+        # @param [ Hash ] options This method currently accepts no options.
         #
         # @return [ Array<Fixnum> ] Array consisting of the deserialized
         #   length, request id, response id, and op code.
-        def self.deserialize(buffer)
+        def self.deserialize(buffer, options = {})
           buffer.get_bytes(16).unpack(HEADER_PACK)
         end
       end
@@ -123,9 +124,10 @@ module Mongo
         # Deserializes a 32-bit Fixnum from the IO stream
         #
         # @param [ String ] buffer Buffer containing the 32-bit integer
+        # @param [ Hash ] options This method currently accepts no options.
         #
         # @return [ Fixnum ] Deserialized Int32
-        def self.deserialize(buffer)
+        def self.deserialize(buffer, options = {})
           buffer.get_int32
         end
       end
@@ -156,9 +158,10 @@ module Mongo
         # Deserializes a 64-bit Fixnum from the IO stream
         #
         # @param [ String ] buffer Buffer containing the 64-bit integer.
+        # @param [ Hash ] options This method currently accepts no options.
         #
         # @return [Fixnum] Deserialized Int64.
-        def self.deserialize(buffer)
+        def self.deserialize(buffer, options = {})
           buffer.get_int64
         end
       end
@@ -198,19 +201,24 @@ module Mongo
         # Deserializes a section of an OP_MSG from the IO stream.
         #
         # @param [ BSON::ByteBuffer ] buffer Buffer containing the sections.
+        # @param [ Hash ] options
+        #
+        # @option options [ Boolean ] :deserialize_as_bson Whether to perform
+        #   section deserialization using BSON types instead of native Ruby types
+        #   wherever possible.
         #
         # @return [ Array<BSON::Document> ] Deserialized sections.
         #
         # @since 2.5.0
-        def self.deserialize(buffer)
+        def self.deserialize(buffer, options = {})
           end_length = (@flag_bits & Msg::FLAGS.index(:checksum_present)) == 1 ? 32 : 0
           sections = []
           until buffer.length == end_length
             case byte = buffer.get_byte
             when PayloadZero::TYPE_BYTE
-              sections << PayloadZero.deserialize(buffer)
+              sections << PayloadZero.deserialize(buffer, options)
             when PayloadOne::TYPE_BYTE
-              sections += PayloadOne.deserialize(buffer)
+              sections += PayloadOne.deserialize(buffer, options)
             else
               raise Error::UnknownPayloadType.new(byte)
             end
@@ -260,12 +268,18 @@ module Mongo
           # Deserializes a section of payload type 0 of an OP_MSG from the IO stream.
           #
           # @param [ BSON::ByteBuffer ] buffer Buffer containing the sections.
+          # @param [ Hash ] options
+          #
+          # @option options [ Boolean ] :deserialize_as_bson Whether to perform
+          #   section deserialization using BSON types instead of native Ruby types
+          #   wherever possible.
           #
           # @return [ Array<BSON::Document> ] Deserialized section.
           #
           # @since 2.5.0
-          def self.deserialize(buffer)
-            BSON::Document.from_bson(buffer)
+          def self.deserialize(buffer, options = {})
+            mode = options[:deserialize_as_bson] ? :bson : nil
+            BSON::Document.from_bson(buffer, **{ mode: mode })
           end
         end
 
@@ -352,10 +366,16 @@ module Mongo
         # Deserializes a document from the IO stream
         #
         # @param [ String ] buffer Buffer containing the BSON encoded document.
+        # @param [ Hash ] options
+        #
+        # @option options [ Boolean ] :deserialize_as_bson Whether to perform
+        #   section deserialization using BSON types instead of native Ruby types
+        #   wherever possible.
         #
         # @return [ Hash ] The decoded BSON document.
-        def self.deserialize(buffer)
-          BSON::Document.from_bson(buffer)
+        def self.deserialize(buffer, options = {})
+          mode = options[:deserialize_as_bson] ? :bson : nil
+          BSON::Document.from_bson(buffer, **{ mode: mode })
         end
 
         # Whether there can be a size limit on this type after serialization.
@@ -389,11 +409,12 @@ module Mongo
         # Deserializes a byte from the byte buffer.
         #
         # @param [ BSON::ByteBuffer ] buffer Buffer containing the value to read.
+        # @param [ Hash ] options This method currently accepts no options.
         #
         # @return [ String ] The byte.
         #
         # @since 2.5.0
-        def self.deserialize(buffer)
+        def self.deserialize(buffer, options = {})
           buffer.get_byte
         end
       end

data/lib/mongo/retryable.rb

@@ -144,7 +144,7 @@ module Mongo
     # @note This only retries read operations on socket errors.
     #
     # @param [ Hash ] options Options.
-    # @param [ Proc ] block The block to execute.
+    # @yield Calls the provided block with no arguments
     #
     # @option options [ String ] :retry_message Message to log when retrying.
     #

data/lib/mongo/server/connection.rb

@@ -400,7 +400,7 @@ module Mongo
         @auth_mechanism || (@server.features.scram_sha_1_enabled? ? :scram : :mongodb_cr)
       end
 
-      def deliver(message, client)
+      def deliver(message, client, options = {})
         begin
           super
         # Important: timeout errors are not handled here

data/lib/mongo/server/connection_base.rb

@@ -115,11 +115,16 @@ module Mongo
       # @param [ Array<Message> ] messages A one-element array containing
       #   the message to dispatch.
       # @param [ Integer ] operation_id The operation id to link messages.
+      # @param [ Hash ] options
+      #
+      # @option options [ Boolean ] :deserialize_as_bson Whether to deserialize
+      #   the response to this message using BSON objects in place of native
+      #   Ruby types wherever possible.
       #
       # @return [ Protocol::Message | nil ] The reply if needed.
       #
       # @since 2.0.0
-      def dispatch(messages, operation_id = nil, client = nil)
+      def dispatch(messages, operation_id = nil, client = nil, options = {})
         # The monitoring code does not correctly handle multiple messages,
         # and the driver internally does not send more than one message at
         # a time ever. Thus prohibit multiple message use for now.
@@ -127,12 +132,12 @@ module Mongo
           raise ArgumentError, 'Can only dispatch one message at a time'
         end
         message = messages.first
-        deliver(message, client)
+        deliver(message, client, options)
       end
 
       private
 
-      def deliver(message, client)
+      def deliver(message, client, options = {})
         if Lint.enabled? && !@socket
           raise Error::LintError, "Trying to deliver a message over a disconnected connection (to #{address})"
         end
@@ -146,7 +151,7 @@ module Mongo
           begin
             socket.write(buffer.to_s)
             result = if message.replyable?
-              Protocol::Message.deserialize(socket, max_message_size, message.request_id)
+              Protocol::Message.deserialize(socket, max_message_size, message.request_id, options)
             else
               nil
             end

data/lib/mongo/server/connection_pool/populator.rb

@@ -21,7 +21,7 @@ module Mongo
     class Populator
       include BackgroundThread
 
-      # @param [ Server::ConnectionPool ] The connection pool.
+      # @param [ Server::ConnectionPool ] pool The connection pool.
       # @param [ Hash ] options The options.
       #
       # @option options [ Logger ] :logger A custom logger to use.

data/lib/mongo/session.rb

@@ -697,7 +697,7 @@ module Mongo
     # The exception instance should already have all of the labels set on it
     # (both client- and server-side generated ones).
     #
-    # @param [ Error ] The exception instance to process.
+    # @param [ Error ] error The exception instance to process.
     #
     # @api private
     def unpin_maybe(error)

data/lib/mongo/srv/monitor.rb

@@ -13,65 +13,94 @@
 # limitations under the License.
 
 module Mongo
-  module SRV
+  module Srv
 
-    # Polls SRV records for the URI that a cluster was created for and
-    # updates the list of servers in the cluster when records change.
+    # Periodically retrieves SRV records for the cluster's SRV URI, and
+    # sets the cluster's server list to the SRV lookup result.
+    #
+    # If an error is encountered during SRV lookup or an SRV record is invalid
+    # or disallowed for security reasons, a warning is logged and monitoring
+    # continues.
     #
     # @api private
     class Monitor
       include Loggable
-
-      MIN_RESCAN_FREQUENCY = 60
+      include BackgroundThread
+
+      MIN_SCAN_INTERVAL = 60
+
+      DEFAULT_TIMEOUT = 10
+
+      # Creates the SRV monitor.
+      #
+      # @param [ Cluster ] cluster The cluster.
+      # @param [ Hash ] options The cluster options.
+      #
+      # @option options [ Float ] :timeout The timeout to use for DNS lookups.
+      # @option options [ URI::SRVProtocol ] :srv_uri The SRV URI to monitor.
+      # @option options [ Hash ] :resolv_options For internal driver use only.
+      #   Options to pass through to Resolv::DNS constructor for SRV lookups.
+      def initialize(cluster, options = nil)
+        options = if options
+          options.dup
+        else
+          {}
+        end
+        @cluster = cluster
+        @resolver = Srv::Resolver.new(options)
+        unless @srv_uri = options.delete(:srv_uri)
+          raise ArgumentError, 'SRV URI is required'
+        end
+        @options = options.freeze
+        @last_result = @srv_uri.srv_result
+        @stop_semaphore = Semaphore.new
+      end
 
       attr_reader :options
 
-      def initialize(cluster, resolver, srv_records, options = nil)
-        @options = options || {}
-        @cluster = cluster
-        @resolver = resolver
-        @records = srv_records
-        @no_records_found = false
-      end
+      attr_reader :cluster
 
-      def start_monitor!
-        @thread = Thread.new do
-          loop do
-            sleep(rescan_frequency)
-            scan!
-          end
-        end
+      # @return [ Srv::Result ] Last known SRV lookup result. Used for
+      #   determining intervals between SRV lookups, which depend on SRV DNS
+      #   records' TTL values.
+      attr_reader :last_result
 
+      def start!
+        super
         ObjectSpace.define_finalizer(self, self.class.finalize(@thread))
       end
 
+      private
+
+      def do_work
+        scan!
+        @stop_semaphore.wait(scan_interval)
+      end
+
       def scan!
-        @old_hosts = @records.hosts
+        old_hosts = last_result.address_strs
 
         begin
-          @records = @resolver.get_records(@records.hostname)
+          last_result = Timeout.timeout(timeout) do
+            @resolver.get_records(@srv_uri.query_hostname)
+          end
         rescue Resolv::ResolvTimeout => e
-          log_warn("Timed out trying to resolve hostname #{@records.hostname}")
+          log_warn("SRV monitor: timed out trying to resolve hostname #{@srv_uri.query_hostname}: #{e.class}: #{e}")
+          return
+        rescue ::Timeout::Error
+          log_warn("SRV monitor: timed out trying to resolve hostname #{@srv_uri.query_hostname} (timeout=#{timeout})")
           return
         rescue Resolv::ResolvError => e
-          log_warn("Unable to resolve hostname #{@records.hostname}")
+          log_warn("SRV monitor: unable to resolve hostname #{@srv_uri.query_hostname}: #{e.class}: #{e}")
           return
         end
 
-        if @records.empty?
-          @no_records_found = true
+        if last_result.empty?
+          log_warn("SRV monitor: hostname #{@srv_uri.query_hostname} resolved to zero records")
           return
         end
 
-        @no_records_found = false
-
-        (@old_hosts - @records.hosts).each do |host|
-          @cluster.remove(host)
-        end
-
-        (@records.hosts - @old_hosts).each do |host|
-          @cluster.add(host)
-        end
+        @cluster.set_server_list(last_result.address_strs)
       end
 
       def self.finalize(thread)
@@ -80,17 +109,19 @@ module Mongo
         end
       end
 
-      private
-
-      def rescan_frequency
-        if @no_records_found
-          Server:: Monitor::HEARTBEAT_FREQUENCY
-        elsif @records.min_ttl.nil?
-          MIN_RESCAN_FREQUENCY
+      def scan_interval
+        if last_result.empty?
+          [cluster.heartbeat_interval, MIN_SCAN_INTERVAL].min
+        elsif last_result.min_ttl.nil?
+          MIN_SCAN_INTERVAL
         else
-          [@records.min_ttl, MIN_RESCAN_FREQUENCY].max
+          [last_result.min_ttl, MIN_SCAN_INTERVAL].max
         end
       end
+
+      def timeout
+        options[:timeout] || DEFAULT_TIMEOUT
+      end
     end
   end
 end