mongo 2.23.0 → 2.24.1

data/lib/mongo/server_selector/base.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 # Copyright (C) 2020 MongoDB Inc.
 #
@@ -16,11 +15,8 @@
 # limitations under the License.
 
 module Mongo
-
   module ServerSelector
-
     class Base
-
       # Initialize the server selector.
       #
       # @example Initialize the selector.
@@ -41,6 +37,8 @@ module Mongo
       #   reads on the server. Hedged reads are not enabled by default. When
       #   specifying this option, it must be in the format: { enabled: true },
       #   where the value of the :enabled key is a boolean value.
+      #   @deprecated Hedged reads are deprecated in MongoDB Server 8.0 and will
+      #     be removed in a future version.
       #
       # @raise [ Error::InvalidServerPreference ] If tag sets are specified
       #   but not allowed.
@@ -48,15 +46,21 @@ module Mongo
       # @api private
       def initialize(options = nil)
         options = options ? options.dup : {}
-        if options[:max_staleness] == -1
-          options.delete(:max_staleness)
-        end
+        options.delete(:max_staleness) if options[:max_staleness] == -1
         @options = options
         @tag_sets = options[:tag_sets] || []
         @max_staleness = options[:max_staleness]
         @hedge = options[:hedge]
 
         validate!
+
+        return if @hedge.nil?
+
+        Mongo::Deprecations.warn(
+          :hedge_read_preference,
+          'The hedge read preference option is deprecated. Hedged reads are ' \
+          'deprecated in MongoDB Server 8.0 and will be removed in a future version.'
+        )
       end
 
       # @return [ Hash ] options The options.
@@ -73,6 +77,9 @@ module Mongo
 
       # @return [ Hash | nil ] hedge The document specifying whether to enable
       #   hedged reads.
+      #
+      # @deprecated Hedged reads are deprecated in MongoDB Server 8.0 and will
+      #   be removed in a future version.
       attr_reader :hedge
 
       # Get the timeout for server selection.
@@ -88,7 +95,7 @@ module Mongo
       #   a server is selected. Will be removed in version 3.0.
       def server_selection_timeout
         @server_selection_timeout ||=
-          (options[:server_selection_timeout] || ServerSelector::SERVER_SELECTION_TIMEOUT)
+          options[:server_selection_timeout] || ServerSelector::SERVER_SELECTION_TIMEOUT
       end
 
       # Get the local threshold boundary for nearest selection in seconds.
@@ -103,7 +110,7 @@ module Mongo
       # @deprecated This setting is now taken from the cluster options when
       #   a server is selected. Will be removed in version 3.0.
       def local_threshold
-        @local_threshold ||= (options[:local_threshold] || ServerSelector::LOCAL_THRESHOLD)
+        @local_threshold ||= options[:local_threshold] || ServerSelector::LOCAL_THRESHOLD
       end
 
       # @api private
@@ -161,13 +168,12 @@ module Mongo
       # @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.
+      #   for mongos pinning.
       # @param [ true | false ] write_aggregation Whether we need a server that
       #   supports writing aggregations (e.g. with $merge/$out) on secondaries.
       # @param [ Array<Server> ] deprioritized A list of servers that should
-      #   be selected from only if no other servers are available. This is
-      #   used to avoid selecting the same server twice in a row when
-      #   retrying a command.
+      #   be selected from only if no other servers are available.
+      #
       # @param [ Float | nil ] :timeout Timeout in seconds for the operation,
       #   if any.
       #
@@ -197,15 +203,20 @@ module Mongo
 
       # Parameters and return values are the same as for select_server, only
       # the +timeout+ param is renamed to +csot_timeout+.
-      private def select_server_impl(cluster, ping, session, write_aggregation, deprioritized, csot_timeout)
+      private def select_server_impl(cluster, _ping, session, write_aggregation, deprioritized, csot_timeout)
         if cluster.topology.is_a?(Cluster::Topology::LoadBalanced)
+          # In load-balanced mode, release the pinned connection if the session
+          # is no longer in a transaction (e.g. after commit or abort).
+          if session&.pinned_connection_global_id && !session.in_transaction?
+            session.unpin
+          end
           return cluster.servers.first
         end
 
         timeout = cluster.options[:server_selection_timeout] || SERVER_SELECTION_TIMEOUT
 
         server_selection_timeout = if csot_timeout && csot_timeout > 0
-                                     [timeout, csot_timeout].min
+                                     [ timeout, csot_timeout ].min
                                    else
                                      timeout
                                    end
@@ -214,23 +225,19 @@ module Mongo
         # 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}"
+          msg = 'Failing server selection due to zero timeout. ' +
+                " Requested #{name} in cluster: #{cluster.summary}"
           raise Error::NoServerAvailable.new(self, cluster, msg)
         end
 
         deadline = Utils.monotonic_time + 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
+          if Mongo::Lint.enabled? && !cluster.sharded?
+            raise Error::LintError, "Session has a pinned server in a non-sharded topology: #{topology}"
           end
 
-          if !session.in_transaction?
-            session.unpin
-          end
+          session.unpin unless session.in_transaction?
 
           if server = session.pinned_server
             # Here we assume that a mongos stays in the topology indefinitely.
@@ -243,7 +250,7 @@ module Mongo
 
               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)"
+                      "(after #{server_selection_timeout} seconds)"
                 raise Error::NoServerAvailable.new(self, cluster, msg)
               end
             end
@@ -252,26 +259,22 @@ module Mongo
           end
         end
 
-        if cluster.replica_set?
-          validate_max_staleness_value_early!
-        end
+        validate_max_staleness_value_early! if cluster.replica_set?
 
         if cluster.addresses.empty?
-          if Lint.enabled?
-            unless cluster.servers.empty?
-              raise Error::LintError, "Cluster has no addresses but has servers: #{cluster.servers.map(&:inspect).join(', ')}"
-            end
+          if Lint.enabled? && !cluster.servers.empty?
+            raise Error::LintError,
+                  "Cluster has no addresses but has servers: #{cluster.servers.map(&:inspect).join(', ')}"
           end
-          msg = "Cluster has no addresses, and therefore will never have a server"
+          msg = 'Cluster has no addresses, and therefore will never have a server'
           raise Error::NoServerAvailable.new(self, cluster, msg)
         end
 
-=begin Add this check in version 3.0.0
-        unless cluster.connected?
-          msg = 'Cluster is disconnected'
-          raise Error::NoServerAvailable.new(self, cluster, msg)
-        end
-=end
+        # Add this check in version 3.0.0
+        #         unless cluster.connected?
+        #           msg = 'Cluster is disconnected'
+        #           raise Error::NoServerAvailable.new(self, cluster, msg)
+        #         end
 
         loop do
           if Lint.enabled?
@@ -287,15 +290,16 @@ module Mongo
           end
 
           server = try_select_server(cluster, write_aggregation: write_aggregation, deprioritized: deprioritized)
+          if server.nil? && deprioritized.any?
+            server = try_select_server(cluster, write_aggregation: write_aggregation, deprioritized: [])
+          end
 
           if server
             unless cluster.topology.compatible?
               raise Error::UnsupportedFeatures, cluster.topology.compatibility_error.to_s
             end
 
-            if session && session.starting_transaction? && cluster.sharded?
-              session.pin_to_server(server)
-            end
+            session.pin_to_server(server) if session && session.starting_transaction? && cluster.sharded?
 
             return server
           end
@@ -303,34 +307,28 @@ module Mongo
           cluster.scan!(false)
 
           time_remaining = deadline - Utils.monotonic_time
-          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
-            break
-          end
+          break unless 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.
         end
 
         msg = "No #{name} server"
-        if is_a?(ServerSelector::Secondary) && !tag_sets.empty?
-          msg += " with tag sets: #{tag_sets}"
-        end
+        msg += " with tag sets: #{tag_sets}" if is_a?(ServerSelector::Secondary) && !tag_sets.empty?
         msg += " is available in cluster: #{cluster.summary} " +
-                "with timeout=#{server_selection_timeout}, " +
-                "LT=#{local_threshold_with_cluster(cluster)}"
+               "with timeout=#{server_selection_timeout}, " +
+               "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
-        if session && session.committing_transaction?
-          e.add_label('UnknownTransactionCommitResult')
-        end
+        e.add_label('UnknownTransactionCommitResult') if session && session.committing_transaction?
         raise e
       end
 
@@ -351,40 +349,36 @@ module Mongo
       # @api private
       def try_select_server(cluster, write_aggregation: false, deprioritized: [])
         servers = if write_aggregation && cluster.replica_set?
-          # 1. Check if ALL servers in cluster support secondary writes.
-          is_write_supported = cluster.servers.reduce(true) do |res, server|
-            res && server.features.merge_out_on_secondary_enabled?
-          end
-
-          if is_write_supported
-            # 2. If all servers support secondary writes, we respect read preference.
-            suitable_servers(cluster)
-          else
-            # 3. Otherwise we fallback to primary for replica set.
-            [cluster.servers.detect(&:primary?)]
-          end
-        else
-          suitable_servers(cluster)
-        end
+                    # 1. Check if ALL servers in cluster support secondary writes.
+                    is_write_supported = cluster.servers.reduce(true) do |res, server|
+                      res && server.features.merge_out_on_secondary_enabled?
+                    end
+
+                    if is_write_supported
+                      # 2. If all servers support secondary writes, we respect read preference.
+                      suitable_servers(cluster, deprioritized)
+                    else
+                      # 3. Otherwise we fallback to primary for replica set.
+                      [ cluster.servers.detect(&:primary?) ]
+                    end
+                  else
+                    suitable_servers(cluster, deprioritized)
+                  end
 
         # This list of servers may be ordered in a specific way
         # by the selector (e.g. for secondary preferred, the first
         # server may be a secondary and the second server may be primary)
         # and we should take the first server here respecting the order
-        server = suitable_server(servers, deprioritized)
+        server = suitable_server(servers)
 
-        if server
-          if Lint.enabled?
-            # It is possible for a server to have a nil average RTT here
-            # because the ARTT comes from description which may be updated
-            # by a background thread while server selection is running.
-            # Currently lint mode is not a public feature, if/when this
-            # changes (https://jira.mongodb.org/browse/RUBY-1576) the
-            # requirement for ARTT to be not nil would need to be removed.
-            if server.average_round_trip_time.nil?
-              raise Error::LintError, "Server #{server.address} has nil average rtt"
-            end
-          end
+        if server && Lint.enabled? && server.average_round_trip_time.nil?
+          # It is possible for a server to have a nil average RTT here
+          # because the ARTT comes from description which may be updated
+          # by a background thread while server selection is running.
+          # Currently lint mode is not a public feature, if/when this
+          # changes (https://jira.mongodb.org/browse/RUBY-1576) the
+          # requirement for ARTT to be not nil would need to be removed.
+          raise Error::LintError, "Server #{server.address} has nil average rtt"
         end
 
         server
@@ -396,15 +390,14 @@ module Mongo
       # latency filtering.
       #
       # @param [ Cluster ] cluster The cluster.
+      # @param [ Array<Server> ] deprioritized A list of servers that should
+      #   be selected from only if no other servers are available.
       #
       # @return [ Array<Server> ] The candidate servers.
       #
       # @api private
-      def candidates(cluster)
-        servers = cluster.servers
-        servers.each do |server|
-          validate_max_staleness_support!(server)
-        end
+      def candidates(cluster, deprioritized = [])
+        servers = cluster.servers.reject { |s| deprioritized.include?(s) }
         if cluster.single?
           servers
         elsif cluster.sharded?
@@ -420,44 +413,55 @@ module Mongo
       # Returns servers satisfying the server selector from the cluster.
       #
       # @param [ Cluster ] cluster The cluster.
+      # @param [ Array<Server> ] deprioritized A list of servers that should
+      #   be selected from only if no other servers are available.
       #
       # @return [ Array<Server> ] The suitable servers.
       #
       # @api private
-      def suitable_servers(cluster)
+      def suitable_servers(cluster, deprioritized = [])
+        result = suitable_servers_impl(cluster, deprioritized)
+        result = suitable_servers_impl(cluster, []) if result.empty? && deprioritized.any?
+        result
+      end
+
+      private
+
+      # Internal implementation of suitable_servers that applies deprioritization
+      # filtering to the candidate servers.
+      #
+      # @param [ Cluster ] cluster The cluster.
+      # @param [ Array<Server> ] deprioritized A list of servers that should
+      #   be excluded from the candidate pool.
+      #
+      # @return [ Array<Server> ] The suitable servers.
+      #
+      # @api private
+      def suitable_servers_impl(cluster, deprioritized)
         if cluster.single?
-          candidates(cluster)
+          candidates(cluster, deprioritized)
         elsif cluster.sharded?
           local_threshold = local_threshold_with_cluster(cluster)
-          servers = candidates(cluster)
+          servers = candidates(cluster, deprioritized)
           near_servers(servers, local_threshold)
         elsif cluster.replica_set?
           validate_max_staleness_value!(cluster)
-          candidates(cluster)
+          candidates(cluster, deprioritized)
         else
           # Unknown cluster - no servers
           []
         end
       end
 
-      private
-
       # Returns a server from the list of servers that is suitable for
       # executing the operation.
       #
       # @param [ Array<Server> ] servers The candidate servers.
-      # @param [ Array<Server> ] deprioritized A list of servers that should
-      #  be selected from only if no other servers are available.
       #
       # @return [ Server | nil ] The suitable server or nil if no suitable
       #  server is available.
-      def suitable_server(servers, deprioritized)
-        preferred = servers - deprioritized
-        if preferred.empty?
-          servers.first
-        else
-          preferred.first
-        end
+      def suitable_server(servers)
+        servers.first
       end
 
       # Convert this server preference definition into a format appropriate
@@ -468,7 +472,7 @@ module Mongo
       # @since 2.0.0
       def full_doc
         @full_doc ||= begin
-          preference = { :mode => self.class.const_get(:SERVER_FORMATTED_NAME) }
+          preference = { mode: self.class.const_get(:SERVER_FORMATTED_NAME) }
           preference.update(tags: tag_sets) unless tag_sets.empty?
           preference.update(maxStalenessSeconds: max_staleness) if max_staleness
           preference.update(hedge: hedge) if hedge
@@ -529,7 +533,7 @@ module Mongo
         # of this method.
 
         candidates = candidates.map do |server|
-          {server: server, artt: server.average_round_trip_time}
+          { server: server, artt: server.average_round_trip_time }
         end.reject do |candidate|
           candidate[:artt].nil?
         end
@@ -540,7 +544,7 @@ module Mongo
           candidate[:artt]
         end
 
-        # Default for legacy signarure
+        # Default for legacy signature
         local_threshold ||= self.local_threshold
 
         threshold = nearest_candidate[:artt] + local_threshold
@@ -578,16 +582,14 @@ module Mongo
         # last_scan here.
         if primary
           candidates.select do |server|
-            validate_max_staleness_support!(server)
             staleness = (server.last_scan - server.last_write_date) -
-                        (primary.last_scan - primary.last_write_date)  +
+                        (primary.last_scan - primary.last_write_date) +
                         server.cluster.heartbeat_interval
             staleness <= @max_staleness
           end
         else
           max_write_date = candidates.collect(&:last_write_date).max
           candidates.select do |server|
-            validate_max_staleness_support!(server)
             staleness = max_write_date - server.last_write_date + server.cluster.heartbeat_interval
             staleness <= @max_staleness
           end
@@ -601,49 +603,39 @@ module Mongo
           raise Error::InvalidServerPreference.new(Error::InvalidServerPreference::NO_MAX_STALENESS_SUPPORT)
         end
 
-        if @hedge
-          unless hedge_allowed?
-            raise Error::InvalidServerPreference.new(Error::InvalidServerPreference::NO_HEDGE_SUPPORT)
-          end
-
-          unless @hedge.is_a?(Hash) && @hedge.key?(:enabled) &&
-              [true, false].include?(@hedge[:enabled])
-            raise Error::InvalidServerPreference.new(
-              "`hedge` value (#{hedge}) is invalid - hedge must be a Hash in the " \
-              "format { enabled: true }"
-            )
-          end
-        end
-      end
+        return unless @hedge
+        raise Error::InvalidServerPreference.new(Error::InvalidServerPreference::NO_HEDGE_SUPPORT) unless hedge_allowed?
 
-      def validate_max_staleness_support!(server)
-        if @max_staleness && !server.features.max_staleness_enabled?
-          raise Error::InvalidServerPreference.new(Error::InvalidServerPreference::NO_MAX_STALENESS_WITH_LEGACY_SERVER)
+        unless @hedge.is_a?(Hash) && @hedge.key?(:enabled) &&
+               [ true, false ].include?(@hedge[:enabled])
+          raise Error::InvalidServerPreference.new(
+            "`hedge` value (#{hedge}) is invalid - hedge must be a Hash in the " \
+            'format { enabled: true }'
+          )
         end
       end
 
       def validate_max_staleness_value_early!
-        if @max_staleness
-          unless @max_staleness >= SMALLEST_MAX_STALENESS_SECONDS
-            msg = "`max_staleness` value (#{@max_staleness}) is too small - it must be at least " +
+        return unless @max_staleness
+        return if @max_staleness >= SMALLEST_MAX_STALENESS_SECONDS
+
+        msg = "`max_staleness` value (#{@max_staleness}) is too small - it must be at least " +
               "`Mongo::ServerSelector::SMALLEST_MAX_STALENESS_SECONDS` (#{ServerSelector::SMALLEST_MAX_STALENESS_SECONDS})"
-            raise Error::InvalidServerPreference.new(msg)
-          end
-        end
+        raise Error::InvalidServerPreference.new(msg)
       end
 
       def validate_max_staleness_value!(cluster)
-        if @max_staleness
-          heartbeat_interval = cluster.heartbeat_interval
-          unless @max_staleness >= [
-            SMALLEST_MAX_STALENESS_SECONDS,
-            min_cluster_staleness = heartbeat_interval + Cluster::IDLE_WRITE_PERIOD_SECONDS,
-          ].max
-            msg = "`max_staleness` value (#{@max_staleness}) is too small - it must be at least " +
-              "`Mongo::ServerSelector::SMALLEST_MAX_STALENESS_SECONDS` (#{ServerSelector::SMALLEST_MAX_STALENESS_SECONDS}) and (the cluster's heartbeat_frequency " +
-              "setting + `Mongo::Cluster::IDLE_WRITE_PERIOD_SECONDS`) (#{min_cluster_staleness})"
-            raise Error::InvalidServerPreference.new(msg)
-          end
+        return unless @max_staleness
+
+        heartbeat_interval = cluster.heartbeat_interval
+        unless @max_staleness >= [
+          SMALLEST_MAX_STALENESS_SECONDS,
+          min_cluster_staleness = heartbeat_interval + Cluster::IDLE_WRITE_PERIOD_SECONDS,
+        ].max
+          msg = "`max_staleness` value (#{@max_staleness}) is too small - it must be at least " +
+                "`Mongo::ServerSelector::SMALLEST_MAX_STALENESS_SECONDS` (#{ServerSelector::SMALLEST_MAX_STALENESS_SECONDS}) and (the cluster's heartbeat_frequency " +
+                "setting + `Mongo::Cluster::IDLE_WRITE_PERIOD_SECONDS`) (#{min_cluster_staleness})"
+          raise Error::InvalidServerPreference.new(msg)
         end
       end
 
@@ -669,12 +661,13 @@ module Mongo
           # the servers list earlier and the wait call below, we should not
           # wait for the full remaining time - wait for up to 0.5 second, then
           # recheck the state.
-          cluster.server_selection_semaphore.wait([time_remaining, 0.5].min)
+          cluster.server_selection_semaphore.wait([ time_remaining, 0.5 ].min)
         else
           if Lint.enabled?
             raise Error::LintError, 'Waiting for server selection without having a server selection semaphore'
           end
-          sleep [time_remaining, 0.25].min
+
+          sleep [ time_remaining, 0.25 ].min
         end
       end
 
@@ -696,17 +689,13 @@ module Mongo
         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
+          thread = server.monitor.instance_variable_get(:@thread)
+          dead_monitors << server if thread.nil? || !thread.alive?
         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 += '. The cluster is disconnected (client may have been closed)' unless cluster.connected?
         msg
       end
     end

data/lib/mongo/server_selector/nearest.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 # Copyright (C) 2014-2020 MongoDB Inc.
 #
@@ -17,17 +16,15 @@
 
 module Mongo
   module ServerSelector
-
     # Encapsulates specifications for selecting near servers given a list
     #   of candidates.
     #
     # @since 2.0.0
     class Nearest < Base
-
       # Name of the this read preference in the server's format.
       #
       # @since 2.5.0
-      SERVER_FORMATTED_NAME = 'nearest'.freeze
+      SERVER_FORMATTED_NAME = 'nearest'
 
       # Get the name of the server mode type.
       #
@@ -62,6 +59,9 @@ module Mongo
       # Whether the hedge option is allowed to be defined for this server preference.
       #
       # @return [ true ] true
+      #
+      # @deprecated Hedged reads are deprecated in MongoDB Server 8.0 and will
+      #   be removed in a future version.
       def hedge_allowed?
         true
       end
@@ -86,7 +86,7 @@ module Mongo
       #   command field value.
       #
       # @since 2.0.0
-      alias :to_mongos :to_doc
+      alias to_mongos to_doc
 
       private
 

data/lib/mongo/server_selector/primary.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 # Copyright (C) 2014-2020 MongoDB Inc.
 #
@@ -16,19 +15,16 @@
 # limitations under the License.
 
 module Mongo
-
   module ServerSelector
-
     # Encapsulates specifications for selecting the primary server given a list
     #   of candidates.
     #
     # @since 2.0.0
     class Primary < Base
-
       # Name of the this read preference in the server's format.
       #
       # @since 2.5.0
-      SERVER_FORMATTED_NAME = 'primary'.freeze
+      SERVER_FORMATTED_NAME = 'primary'
 
       # Get the name of the server mode type.
       #
@@ -63,6 +59,9 @@ module Mongo
       # Whether the hedge option is allowed to be defined for this server preference.
       #
       # @return [ false ] false
+      #
+      # @deprecated Hedged reads are deprecated in MongoDB Server 8.0 and will
+      #   be removed in a future version.
       def hedge_allowed?
         false
       end