mongo 2.9.2 → 2.10.0.rc0

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

@@ -20,6 +20,7 @@ module Mongo
     #
     # @since 2.0.0
     module Specifiable
+      include Unpinnable
 
       # The field for database name.
       #
@@ -564,6 +565,45 @@ module Mongo
       def acknowledged_write?
         write_concern.nil? || write_concern.acknowledged?
       end
+
+      private
+
+      def validate_result(result)
+        unpin_maybe(session) do
+          add_error_labels do
+            result.validate!
+          end
+        end
+      end
+
+      # Adds error labels to exceptions raised in the yielded to block,
+      # which should perform MongoDB operations and raise Mongo::Errors on
+      # failure. This method handles network errors (Error::SocketError)
+      # and server-side errors (Error::OperationFailure); it does not
+      # handle server selection errors (Error::NoServerAvailable), for which
+      # labels are added in the server selection code.
+      def add_error_labels
+        begin
+          yield
+        rescue Mongo::Error::SocketError => e
+          if session && session.in_transaction? && !session.committing_transaction?
+            e.add_label('TransientTransactionError')
+          end
+          if session && session.committing_transaction?
+            e.add_label('UnknownTransactionCommitResult')
+          end
+          raise e
+        rescue Mongo::Error::OperationFailure => e
+          if session && session.committing_transaction?
+            if e.write_retryable? || e.wtimeout? || (e.write_concern_error? &&
+                !Session::UNLABELED_WRITE_CONCERN_CODES.include?(e.write_concern_error_code)
+            ) || e.max_time_ms_expired?
+              e.add_label('UnknownTransactionCommitResult')
+            end
+          end
+          raise e
+        end
+      end
     end
   end
 end

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

@@ -0,0 +1,39 @@
+# Copyright (C) 2014-2019 MongoDB, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module Mongo
+  module Operation
+    module Unpinnable
+
+      private
+
+      # Unpins the session if the session is pinned and the yielded to block
+      # raises errors that are required to unpin the session.
+      #
+      # @note This method takes the session as an argument because Unpinnable
+      #   is included in BulkWrite which does not store the session in the
+      #   receiver (despite Specifiable doing so).
+      #
+      # @param [ Session | nil ] Session to consider.
+      def unpin_maybe(session)
+        yield
+      rescue Mongo::Error => e
+        if session
+          session.unpin_maybe(e)
+        end
+        raise
+      end
+    end
+  end
+end

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

@@ -39,7 +39,7 @@ module Mongo
           else
             self.class::Command.new(spec).execute(server)
           end
-        result.validate!
+        validate_result(result)
       end
 
       # Execute the bulk write operation.

data/lib/mongo/protocol/update.rb

@@ -192,8 +192,12 @@ module Mongo
           updates = BSON::Document.new
           updates.store(Message::Q, filter)
           updates.store(U, update)
-          updates.store(MULTI, flags.include?(:multi_update))
-          updates.store(UPSERT, flags.include?(:upsert))
+          if flags.include?(:multi_update)
+            updates.store(MULTI, true)
+          end
+          if flags.include?(:upsert)
+            updates.store(UPSERT, true)
+          end
           document.store(UPDATE, collection)
           document.store(Message::ORDERED, true)
           document.store(UPDATES, [ updates ])

data/lib/mongo/retryable.rb

@@ -118,7 +118,7 @@ module Mongo
       elsif client.max_read_retries > 0
         legacy_read_with_retry(session, server_selector, &block)
       else
-        server = select_server(cluster, server_selector)
+        server = select_server(cluster, server_selector, session)
         yield server
       end
     end
@@ -200,7 +200,7 @@ module Mongo
       # If we are here, session is not nil. A session being nil would have
       # failed retry_write_allowed? check.
 
-      server = cluster.next_primary
+      server = select_server(cluster, ServerSelector.primary, session)
 
       unless ending_transaction || server.retry_writes?
         return legacy_write_with_retry(server, session, &block)
@@ -213,12 +213,75 @@ module Mongo
         if session.in_transaction? && !ending_transaction
           raise
         end
-        retry_write(e, txn_num, &block)
+        retry_write(e, session, txn_num, &block)
       rescue Error::OperationFailure => e
         if (session.in_transaction? && !ending_transaction) || !e.write_retryable?
           raise
         end
-        retry_write(e, txn_num, &block)
+        retry_write(e, session, txn_num, &block)
+      end
+    end
+
+    # Retryable writes wrapper for operations not supporting modern retryable
+    # writes.
+    #
+    # If the driver is configured to use modern retryable writes, this method
+    # yields to the passed block exactly once, thus not retrying any writes.
+    #
+    # If the driver is configured to use legacy retryable writes, this method
+    # delegates to legacy_write_with_retry which performs write retries using
+    # legacy logic.
+    #
+    # @param [ nil | Session ] session Optional session to use with the operation.
+    # @param [ nil | Hash | WriteConcern::Base ] write_concern The write concern.
+    #
+    # @yieldparam [ Server ] server The server to which the write should be sent.
+    #
+    # @api private
+    def nro_write_with_retry(session, write_concern, &block)
+      if session && session.client.options[:retry_writes]
+        server = select_server(cluster, ServerSelector.primary, session)
+        yield server
+      else
+        legacy_write_with_retry(nil, session, &block)
+      end
+    end
+
+    # Implements legacy write retrying functionality by yielding to the passed
+    # block one or more times.
+    #
+    # This method is used for operations which are not supported by modern
+    # retryable writes, such as delete_many and update_many.
+    #
+    # @param [ Server ] server The server which should be used for the
+    #   operation. If not provided, the current primary will be retrieved from
+    #   the cluster.
+    # @param [ nil | Session ] session Optional session to use with the operation.
+    #
+    # @yieldparam [ Server ] server The server to which the write should be sent.
+    #
+    # @api private
+    def legacy_write_with_retry(server = nil, session = nil)
+      # This is the pre-session retry logic, and is not subject to
+      # current retryable write specifications.
+      # In particular it does not retry on SocketError and SocketTimeoutError.
+      attempt = 0
+      begin
+        attempt += 1
+        server ||= select_server(cluster, ServerSelector.primary, session)
+        yield server
+      rescue Error::OperationFailure => e
+        server = nil
+        if attempt > client.max_write_retries
+          raise
+        end
+        if e.write_retryable? && !(session && session.in_transaction?)
+          log_retry(e, message: 'Legacy write retry')
+          cluster.scan!(false)
+          retry
+        else
+          raise
+        end
       end
     end
 
@@ -226,25 +289,25 @@ module Mongo
 
     def modern_read_with_retry(session, server_selector, &block)
       attempt = 0
-      server = select_server(cluster, server_selector)
+      server = select_server(cluster, server_selector, session)
       begin
         yield server
       rescue Error::SocketError, Error::SocketTimeoutError => e
         if session.in_transaction?
           raise
         end
-        retry_read(e, server_selector, &block)
+        retry_read(e, server_selector, session, &block)
       rescue Error::OperationFailure => e
         if session.in_transaction? || !e.write_retryable?
           raise
         end
-        retry_read(e, server_selector, &block)
+        retry_read(e, server_selector, session, &block)
       end
     end
 
     def legacy_read_with_retry(session, server_selector)
       attempt = 0
-      server = select_server(cluster, server_selector)
+      server = select_server(cluster, server_selector, session)
       begin
         attempt += 1
         yield server
@@ -253,7 +316,7 @@ module Mongo
           raise
         end
         log_retry(e, message: 'Legacy read retry')
-        server = select_server(cluster, server_selector)
+        server = select_server(cluster, server_selector, session)
         retry
       rescue Error::OperationFailure => e
         if cluster.sharded? && e.retryable? && !(session && session.in_transaction?)
@@ -262,7 +325,7 @@ module Mongo
           end
           log_retry(e, message: 'Legacy read retry')
           sleep(client.read_retry_interval)
-          server = select_server(cluster, server_selector)
+          server = select_server(cluster, server_selector, session)
           retry
         else
           raise
@@ -285,9 +348,9 @@ module Mongo
       end
     end
 
-    def retry_read(original_error, server_selector, &block)
+    def retry_read(original_error, server_selector, session, &block)
       begin
-        server = select_server(cluster, server_selector)
+        server = select_server(cluster, server_selector, session)
       rescue
         raise original_error
       end
@@ -306,13 +369,13 @@ module Mongo
       end
     end
 
-    def retry_write(original_error, txn_num, &block)
+    def retry_write(original_error, session, txn_num, &block)
       # We do not request a scan of the cluster here, because error handling
       # for the error which triggered the retry should have updated the
       # server description and/or topology as necessary (specifically,
       # a socket error or a not master error should have marked the respective
       # server unknown). Here we just need to wait for server selection.
-      server = cluster.next_primary
+      server = select_server(cluster, ServerSelector.primary, session)
       raise original_error unless (server.retry_writes? && txn_num)
       log_retry(original_error, message: 'Write retry')
       yield(server, txn_num, true)
@@ -325,33 +388,10 @@ module Mongo
       raise original_error
     end
 
-    def legacy_write_with_retry(server = nil, session = nil)
-      # This is the pre-session retry logic, and is not subject to
-      # current retryable write specifications.
-      # In particular it does not retry on SocketError and SocketTimeoutError.
-      attempt = 0
-      begin
-        attempt += 1
-        yield(server || cluster.next_primary)
-      rescue Error::OperationFailure => e
-        server = nil
-        if attempt > client.max_write_retries
-          raise
-        end
-        if e.write_retryable? && !(session && session.in_transaction?)
-          log_retry(e, message: 'Legacy write retry')
-          cluster.scan!(false)
-          retry
-        else
-          raise
-        end
-      end
-    end
-
     # This is a separate method to make it possible for the test suite to
     # assert that server selection is performed during retry attempts.
-    def select_server(cluster, server_selector)
-      server_selector.select_server(cluster)
+    def select_server(cluster, server_selector, session)
+      server_selector.select_server(cluster, nil, session)
     end
 
     # Log a warning so that any application slow down is immediately obvious.

data/lib/mongo/server/connection.rb

@@ -175,9 +175,16 @@ module Mongo
       def do_connect
         socket = address.socket(socket_timeout, ssl_options,
           connect_timeout: address.connect_timeout)
-        handshake!(socket)
-        pending_connection = PendingConnection.new(socket, @server, monitoring, options)
-        authenticate!(pending_connection)
+
+        begin
+          handshake!(socket)
+          pending_connection = PendingConnection.new(socket, @server, monitoring, options)
+          authenticate!(pending_connection)
+        rescue Exception
+          socket.close
+          raise
+        end
+
         socket
       end
       private :do_connect

data/lib/mongo/server/description.rb

@@ -217,7 +217,7 @@ module Mongo
       # @return [ Features ] features The features for the server.
       def features
         if unknown?
-          raise ArgumentError, "An unknown server's features are not known"
+          return Features.new(0..0, address.to_s)
         end
         @features
       end
@@ -705,6 +705,30 @@ module Mongo
       end
       alias_method :eql?, :==
 
+      # @api private
+      def server_version_gte?(version)
+        required_wv = case version
+          when '4.2'
+            8
+          when '4.0'
+            7
+          when '3.6'
+            6
+          when '3.4'
+            5
+          when '3.2'
+            4
+          when '3.0'
+            3
+          when '2.6'
+            2
+          else
+            raise ArgumentError, "Bogus required version #{version}"
+          end
+
+        required_wv >= min_wire_version && required_wv <= max_wire_version
+      end
+
       private
 
       def compare_config(other)

data/lib/mongo/server/monitor/connection.rb

@@ -235,7 +235,7 @@ module Mongo
         end
 
         def retry_message
-          "Retrying ismaster on #{address}"
+          "Retrying ismaster in monitor for #{address}"
         end
       end
     end

data/lib/mongo/server_selector.rb

@@ -74,5 +74,15 @@ module Mongo
       Mongo::Lint.validate_underscore_read_preference(preference)
       PREFERENCES.fetch((preference[:mode] || :primary).to_sym).new(preference)
     end
+
+    # Returns the primary server selector.
+    #
+    # A call to this method is equivalent to `get(mode: :primary)`, except the
+    # resulting server selector object is cached and not recreated each time.
+    #
+    # @api private
+    def primary
+      @primary ||= get(mode: :primary)
+    end
   end
 end

data/lib/mongo/server_selector/selectable.rb

@@ -92,17 +92,85 @@ module Mongo
         "#<#{self.class.name}:0x#{object_id} tag_sets=#{tag_sets.inspect} max_staleness=#{max_staleness.inspect}>"
       end
 
-      # Select a server from eligible candidates.
-      #
-      # @example Select a server from the cluster.
-      #   selector.select_server(cluster)
-      #
-      # @param [ Mongo::Cluster ] cluster The cluster from which to select an eligible server.
+      # Select a server from the specified cluster, taking into account
+      # mongos pinning for the specified session.
+      #
+      # If the session is given and has a pinned server, this server is the
+      # only server considered for selection. If the server is of type mongos,
+      # it is returned immediately; otherwise monitoring checks on this
+      # server are initiated to update its status, and if the server becomes
+      # a mongos within the server selection timeout, it is returned.
+      #
+      # If no session is given or the session does not have a pinned server,
+      # normal server selection process is performed among all servers in the
+      # specified cluster matching the preference of this server selector
+      # object. Monitoring checks are initiated on servers in the cluster until
+      # a suitable server is found, up to the server selection timeout.
+      #
+      # If a suitable server is not found within the server selection timeout,
+      # this method raises Error::NoServerAvailable.
+      #
+      # @param [ Mongo::Cluster ] cluster The cluster from which to select
+      #   an eligible server.
+      # @param [ true, false ] ping Whether to ping the server before selection.
+      #   Deprecated and ignored.
+      # @param [ Session | nil ] session Optional session to take into account
+      #   for mongos pinning. Added in version 2.10.0.
       #
       # @return [ Mongo::Server ] A server matching the server preference.
       #
+      # @raise [ Error::NoServerAvailable ] No server was found matching the
+      #   specified preference / pinning requirement in the server selection
+      #   timeout.
+      # @raise [ Error::LintError ] An unexpected condition was detected, and
+      #   lint mode is enabled.
+      #
       # @since 2.0.0
-      def select_server(cluster, ping = nil)
+      def select_server(cluster, ping = nil, session = nil)
+        server_selection_timeout = cluster.options[:server_selection_timeout] || SERVER_SELECTION_TIMEOUT
+
+        # Special handling for zero timeout: if we have to select a server,
+        # and the timeout is zero, fail immediately (since server selection
+        # will take some non-zero amount of time in any case).
+        if server_selection_timeout == 0
+          msg = "Failing server selection due to zero timeout. " +
+            " Requested #{name} in cluster: #{cluster.summary}"
+          raise Error::NoServerAvailable.new(self, cluster, msg)
+        end
+
+        deadline = Time.now + server_selection_timeout
+
+        if session && session.pinned_server
+          if Mongo::Lint.enabled?
+            unless cluster.sharded?
+              raise Error::LintError, "Session has a pinned server in a non-sharded topology: #{topology}"
+            end
+          end
+
+          if !session.in_transaction?
+            session.unpin
+          end
+
+          if server = session.pinned_server
+            # Here we assume that a mongos stays in the topology indefinitely.
+            # This will no longer be the case once SRV polling is implemented.
+
+            unless server.mongos?
+              while (time_remaining = deadline - Time.now) > 0
+                wait_for_server_selection(cluster, time_remaining)
+              end
+
+              unless server.mongos?
+                msg = "The session being used is pinned to the server which is not a mongos: #{server.summary} " +
+                  "(after #{server_selection_timeout} seconds)"
+                raise Error::NoServerAvailable.new(self, cluster, msg)
+              end
+            end
+
+            return server
+          end
+        end
+
         if cluster.replica_set?
           validate_max_staleness_value_early!
         end
@@ -121,10 +189,7 @@ module Mongo
           raise Error::NoServerAvailable.new(self, cluster, msg)
         end
 =end
-        @local_threshold = cluster.options[:local_threshold] || LOCAL_THRESHOLD
-        @server_selection_timeout = cluster.options[:server_selection_timeout] || SERVER_SELECTION_TIMEOUT
-        deadline = Time.now + server_selection_timeout
-        while (time_remaining = deadline - Time.now) > 0
+        loop do
           servers = candidates(cluster)
           if Lint.enabled?
             servers.each do |server|
@@ -152,36 +217,41 @@ module Mongo
               raise Error::NoServerAvailable.new(self, cluster, msg)
             end
 
+            if session && session.starting_transaction? && cluster.sharded?
+              session.pin(server)
+            end
+
             return server
           end
+
           cluster.scan!(false)
-          if cluster.server_selection_semaphore
-            cluster.server_selection_semaphore.wait(time_remaining)
+
+          time_remaining = deadline - Time.now
+          if time_remaining > 0
+            wait_for_server_selection(cluster, time_remaining)
+
+            # If we wait for server selection, perform another round of
+            # attempting to locate a suitable server. Otherwise server selection
+            # can raise NoServerAvailable message when the diagnostics
+            # reports an available server of the requested type.
           else
-            if Lint.enabled?
-              raise Error::LintError, 'Waiting for server selection without having a server selection semaphore'
-            end
-            sleep 0.25
+            break
           end
         end
 
         msg = "No #{name} server is available in cluster: #{cluster.summary} " +
                 "with timeout=#{server_selection_timeout}, " +
-                "LT=#{local_threshold}"
-        dead_monitors = []
-        cluster.servers_list.each do |server|
-          thread = server.monitor.instance_variable_get('@thread')
-          if thread.nil? || !thread.alive?
-            dead_monitors << server
-          end
-        end
-        if dead_monitors.any?
-          msg += ". The following servers have dead monitor threads: #{dead_monitors.map(&:summary).join(', ')}"
+                "LT=#{local_threshold_with_cluster(cluster)}"
+        msg += server_selection_diagnostic_message(cluster)
+        raise Error::NoServerAvailable.new(self, cluster, msg)
+      rescue Error::NoServerAvailable => e
+        if session && session.in_transaction? && !session.committing_transaction?
+          e.add_label('TransientTransactionError')
         end
-        unless cluster.connected?
-          msg += ". The cluster is disconnected (client may have been closed)"
+        if session && session.committing_transaction?
+          e.add_label('UnknownTransactionCommitResult')
         end
-        raise Error::NoServerAvailable.new(self, cluster, msg)
+        raise e
       end
 
       # Get the timeout for server selection.
@@ -200,6 +270,10 @@ module Mongo
           (options[:server_selection_timeout] || ServerSelector::SERVER_SELECTION_TIMEOUT)
       end
 
+      def local_threshold_with_cluster(cluster)
+        options[:local_threshold] || cluster.options[:local_threshold] || LOCAL_THRESHOLD
+      end
+
       # Get the local threshold boundary for nearest selection in seconds.
       #
       # @example Get the local threshold.
@@ -229,7 +303,10 @@ module Mongo
         if cluster.single?
           cluster.servers.each { |server| validate_max_staleness_support!(server) }
         elsif cluster.sharded?
-          near_servers(cluster.servers).each { |server| validate_max_staleness_support!(server) }
+          local_threshold = local_threshold_with_cluster(cluster)
+          near_servers(cluster.servers, local_threshold).each do |server|
+            validate_max_staleness_support!(server)
+          end
         else
           validate_max_staleness_value!(cluster) unless cluster.unknown?
           select(cluster.servers)
@@ -276,13 +353,17 @@ module Mongo
       #
       # @param [ Array ] candidates List of candidate servers to select the
       #   near servers from.
+      # @param [ Integer ] local_threshold Local threshold. This parameter
+      #   will be required in driver version 3.0.
       #
       # @return [ Array ] The near servers.
       #
       # @since 2.0.0
-      def near_servers(candidates = [])
+      def near_servers(candidates = [], local_threshold = nil)
         return candidates if candidates.empty?
         nearest_server = candidates.min_by(&:average_round_trip_time)
+        # Default for legacy signarure
+        local_threshold ||= self.local_threshold
         threshold = nearest_server.average_round_trip_time + local_threshold
         candidates.select { |server| server.average_round_trip_time <= threshold }.shuffle!
       end
@@ -363,6 +444,65 @@ module Mongo
           end
         end
       end
+
+      # Waits for server state changes in the specified cluster.
+      #
+      # If the cluster has a server selection semaphore, waits on that
+      # semaphore up to the specified remaining time. Any change in server
+      # state resulting from SDAM will immediately wake up this method and
+      # cause it to return.
+      #
+      # If the cluster des not have a server selection semaphore, waits
+      # the smaller of 0.25 seconds and the specified remaining time.
+      # This functionality is provided for backwards compatibilty only for
+      # applications directly invoking the server selection process.
+      # If lint mode is enabled and the cluster does not have a server
+      # selection semaphore, Error::LintError will be raised.
+      #
+      # @param [ Cluster ] cluster The cluster to wait for.
+      # @param [ Numeric ] time_remaining Maximum time to wait, in seconds.
+      def wait_for_server_selection(cluster, time_remaining)
+        if cluster.server_selection_semaphore
+          cluster.server_selection_semaphore.wait(time_remaining)
+        else
+          if Lint.enabled?
+            raise Error::LintError, 'Waiting for server selection without having a server selection semaphore'
+          end
+          sleep [time_remaining, 0.25].min
+        end
+      end
+
+      # Creates a diagnostic message when server selection fails.
+      #
+      # The diagnostic message includes the following information, as applicable:
+      #
+      # - Servers having dead monitor threads
+      # - Cluster is disconnected
+      #
+      # If none of the conditions for diagnostic messages apply, an empty string
+      # is returned.
+      #
+      # @param [ Cluster ] cluster The cluster on which server selection was
+      #   performed.
+      #
+      # @return [ String ] The diagnostic message.
+      def server_selection_diagnostic_message(cluster)
+        msg = ''
+        dead_monitors = []
+        cluster.servers_list.each do |server|
+          thread = server.monitor.instance_variable_get('@thread')
+          if thread.nil? || !thread.alive?
+            dead_monitors << server
+          end
+        end
+        if dead_monitors.any?
+          msg += ". The following servers have dead monitor threads: #{dead_monitors.map(&:summary).join(', ')}"
+        end
+        unless cluster.connected?
+          msg += ". The cluster is disconnected (client may have been closed)"
+        end
+        msg
+      end
     end
   end
 end