mongo 2.12.1 → 2.13.0

data/lib/mongo/server/push_monitor.rb

@@ -0,0 +1,173 @@
+# Copyright (C) 2020 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
+  class Server
+
+    # A monitor utilizing server-pushed ismaster requests.
+    #
+    # When a Monitor handshakes with a 4.4+ server, it creates an instance
+    # of PushMonitor. PushMonitor subsequently executes server-pushed ismaster
+    # (i.e. awaited & exhausted ismaster) to receive topology changes from the
+    # server as quickly as possible. The Monitor still monitors the server
+    # for round-trip time calculations and to perform immediate checks as
+    # requested by the application.
+    #
+    # @api private
+    class PushMonitor
+      extend Forwardable
+      include BackgroundThread
+
+      def initialize(monitor, topology_version, monitoring, **options)
+        if topology_version.nil?
+          raise ArgumentError, 'Topology version must be provided but it was nil'
+        end
+        @monitor = monitor
+        @topology_version = topology_version
+        @monitoring = monitoring
+        @options = options
+        @lock = Mutex.new
+      end
+
+      # @return [ Monitor ] The monitor to which this push monitor is attached.
+      attr_reader :monitor
+
+      # @return [ TopologyVersion ] Most recently received topology version.
+      attr_reader :topology_version
+
+      # @return [ Monitoring ] monitoring The monitoring.
+      attr_reader :monitoring
+
+      # @return [ Hash ] Push monitor options.
+      attr_reader :options
+
+      # @return [ Server ] The server that is being monitored.
+      def_delegator :monitor, :server
+
+      def start!
+        @lock.synchronize do
+          super
+        end
+      end
+
+      def stop!
+        @lock.synchronize do
+          @stop_requested = true
+          if @connection
+            # Interrupt any in-progress exhausted ismaster reads by
+            # disconnecting the connection.
+            @connection.send(:socket).close
+          end
+        end
+        super.tap do
+          @lock.synchronize do
+            if @connection
+              @connection.disconnect!
+              @connection = nil
+            end
+          end
+        end
+      end
+
+      def do_work
+        @lock.synchronize do
+          return if @stop_requested
+        end
+
+        result = monitoring.publish_heartbeat(server, awaited: true) do
+          ismaster
+        end
+        new_description = monitor.run_sdam_flow(result, awaited: true)
+        # When ismaster fails due to a fail point, the response does not
+        # include topology version. In this case we need to keep our existing
+        # topology version so that we can resume monitoring.
+        # The spec does not appear to directly address this case but
+        # https://github.com/mongodb/specifications/blob/master/source/server-discovery-and-monitoring/server-monitoring.rst#streaming-ismaster
+        # says that topologyVersion should only be updated from successful
+        # ismaster responses.
+        if new_description.topology_version
+          @topology_version = new_description.topology_version
+        end
+      rescue Mongo::Error => exc
+        msg = "Error running awaited ismaster on #{server.address}"
+        Utils.warn_monitor_exception(msg, exc,
+          logger: options[:logger],
+          log_prefix: options[:log_prefix],
+          bg_error_backtrace: options[:bg_error_backtrace],
+        )
+      end
+
+      def ismaster
+        @lock.synchronize do
+          if @connection && @connection.pid != Process.pid
+            log_warn("Detected PID change - Mongo client should have been reconnected (old pid #{@connection.pid}, new pid #{Process.pid}")
+            @connection.disconnect!
+            @connection = nil
+          end
+        end
+
+        @lock.synchronize do
+          unless @connection
+            @server_pushing = false
+            connection = PushMonitor::Connection.new(server.address, options)
+            connection.connect!
+            @connection = connection
+          end
+        end
+
+        resp_msg = begin
+          unless @server_pushing
+            write_ismaster
+          end
+          read_response
+        rescue Mongo::Error
+          @lock.synchronize do
+            @connection.disconnect!
+            @connection = nil
+          end
+          raise
+        end
+        @server_pushing = resp_msg.flags.include?(:more_to_come)
+        result = resp_msg.documents.first
+      end
+
+      def write_ismaster
+        payload = Monitor::Connection::ISMASTER_OP_MSG.merge(
+          topologyVersion: topology_version.to_doc,
+          maxAwaitTimeMS: monitor.heartbeat_interval * 1000,
+        )
+
+        req_msg = Protocol::Msg.new([:exhaust_allowed], {}, payload)
+        @lock.synchronize { @connection }.write_bytes(req_msg.serialize.to_s)
+      end
+
+      def read_response
+        if timeout = options[:connect_timeout]
+          if timeout < 0
+            raise Mongo::SocketTimeoutError, "Requested to read with a negative timeout: #{}"
+          elsif timeout > 0
+            timeout += options[:heartbeat_frequency] || Monitor::DEFAULT_HEARTBEAT_INTERVAL
+          end
+        end
+        # We set the timeout twice: once passed into read_socket which applies
+        # to each individual read operation, and again around the entire read.
+        Timeout.timeout(timeout, Error::SocketTimeoutError, "Failed to read an awaited ismaster response in #{timeout} seconds") do
+          @lock.synchronize { @connection }.read_response(socket_timeout: timeout)
+        end
+      end
+    end
+  end
+end
+
+require 'mongo/server/push_monitor/connection'

data/{spec/runners/transactions/context.rb → lib/mongo/server/push_monitor/connection.rb}

@@ -1,4 +1,4 @@
-# Copyright (C) 2019 MongoDB, Inc.
+# Copyright (C) 2020 MongoDB Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -13,19 +13,14 @@
 # limitations under the License.
 
 module Mongo
-  module Transactions
-    Context = Struct.new(
-      :session0,
-      :session1,
-      :session,
-    ) do
-      def transform_arguments(arguments)
-        arguments.dup.tap do |out|
-          [:session].each do |key|
-            if out[key]
-              out[key] = send(key)
-            end
-          end
+  class Server
+    class PushMonitor
+
+      # @api private
+      class Connection < Server::Monitor::Connection
+
+        def socket_timeout
+          options[:socket_timeout]
         end
       end
     end

data/lib/mongo/server/round_trip_time_averager.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2018-2019 MongoDB, Inc.
+# Copyright (C) 2018-2020 MongoDB Inc.
 
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -34,7 +34,12 @@ module Mongo
         start = Time.now
         begin
           rv = yield
-        rescue Exception => exc
+        rescue Error::SocketError, Error::SocketTimeoutError
+          # If we encountered a network error, the round-trip is not
+          # complete and thus RTT for it does not make sense.
+          raise
+        rescue Error, Error::AuthError => exc
+          # For other errors, RTT is valid.
         end
         last_round_trip_time = Time.now - start
 
@@ -46,7 +51,11 @@ module Mongo
           update_average_round_trip_time
         end
 
-        [rv, exc, last_round_trip_time, average_round_trip_time]
+        if exc
+          raise exc
+        else
+          rv
+        end
       end
 
       private

data/lib/mongo/server_selector.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2014-2019 MongoDB, Inc.
+# Copyright (C) 2014-2020 MongoDB Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require 'mongo/server_selector/selectable'
+require 'mongo/server_selector/base'
 require 'mongo/server_selector/nearest'
 require 'mongo/server_selector/primary'
 require 'mongo/server_selector/primary_preferred'

data/lib/mongo/server_selector/{selectable.rb → base.rb}

@@ -1,4 +1,4 @@
-# Copyright (C) 2014-2019 MongoDB, Inc.
+# Copyright (C) 2020 MongoDB Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -13,12 +13,10 @@
 # limitations under the License.
 
 module Mongo
+
   module ServerSelector
 
-    # Provides common behavior for filtering a list of servers by server mode or tag set.
-    #
-    # @since 2.0.0
-    module Selectable
+    class Base
 
       # Initialize the server selector.
       #
@@ -36,19 +34,25 @@ module Mongo
       #   in seconds, that a secondary can suffer and still be eligible for a read.
       #   A value of -1 is treated identically to nil, which is to not
       #   have a maximum staleness.
+      # @option options [ Hash | nil ] hedge A Hash specifying whether to enable hedged
+      #   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.
       #
       # @raise [ Error::InvalidServerPreference ] If tag sets are specified
       #   but not allowed.
       #
-      # @since 2.0.0
+      # @api private
       def initialize(options = nil)
         options = options ? options.dup : {}
         if options[:max_staleness] == -1
           options.delete(:max_staleness)
         end
-        @options = options.freeze
-        @tag_sets = (options[:tag_sets] || []).freeze
+        @options = options
+        @tag_sets = options[:tag_sets] || []
         @max_staleness = options[:max_staleness]
+        @hedge = options[:hedge]
+
         validate!
       end
 
@@ -58,26 +62,50 @@ module Mongo
       # @return [ Array ] tag_sets The tag sets used to select servers.
       attr_reader :tag_sets
 
-      # @return [ Integer ] max_staleness The maximum replication lag, in seconds, that a
-      #   secondary can suffer and still be eligible for a read.
+      # @return [ Integer ] max_staleness The maximum replication lag, in
+      #   seconds, that a secondary can suffer and still be eligible for a read.
       #
       # @since 2.4.0
       attr_reader :max_staleness
 
-      # Check equality of two server selector.
+      # @return [ Hash | nil ] hedge The document specifying whether to enable
+      #   hedged reads.
+      attr_reader :hedge
+
+      # Get the timeout for server selection.
       #
-      # @example Check server selector equality.
-      #   preference == other
+      # @example Get the server selection timeout, in seconds.
+      #   selector.server_selection_timeout
       #
-      # @param [ Object ] other The other preference.
+      # @return [ Float ] The timeout.
       #
-      # @return [ true, false ] Whether the objects are equal.
+      # @since 2.0.0
+      #
+      # @deprecated This setting is now taken from the cluster options when
+      #   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)
+      end
+
+      # Get the local threshold boundary for nearest selection in seconds.
+      #
+      # @example Get the local threshold.
+      #   selector.local_threshold
+      #
+      # @return [ Float ] The local threshold.
       #
       # @since 2.0.0
-      def ==(other)
-        name == other.name &&
-          tag_sets == other.tag_sets &&
-            max_staleness == other.max_staleness
+      #
+      # @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)
+      end
+
+      # @api private
+      def local_threshold_with_cluster(cluster)
+        options[:local_threshold] || cluster.options[:local_threshold] || LOCAL_THRESHOLD
       end
 
       # Inspect the server selector.
@@ -89,7 +117,22 @@ module Mongo
       #
       # @since 2.2.0
       def inspect
-        "#<#{self.class.name}:0x#{object_id} tag_sets=#{tag_sets.inspect} max_staleness=#{max_staleness.inspect}>"
+        "#<#{self.class.name}:0x#{object_id} tag_sets=#{tag_sets.inspect} max_staleness=#{max_staleness.inspect} hedge=#{hedge}>"
+      end
+
+      # Check equality of two server selectors.
+      #
+      # @example Check server selector equality.
+      #   preference == other
+      #
+      # @param [ Object ] other The other preference.
+      #
+      # @return [ true, false ] Whether the objects are equal.
+      #
+      # @since 2.0.0
+      def ==(other)
+        name == other.name && hedge == other.hedge &&
+          max_staleness == other.max_staleness && tag_sets == other.tag_sets
       end
 
       # Select a server from the specified cluster, taking into account
@@ -174,6 +217,7 @@ module Mongo
         if cluster.replica_set?
           validate_max_staleness_value_early!
         end
+
         if cluster.addresses.empty?
           if Lint.enabled?
             unless cluster.servers.empty?
@@ -183,46 +227,22 @@ module Mongo
           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
+
         loop do
-          servers = candidates(cluster)
-          if Lint.enabled?
-            servers.each do |server|
-              # 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
-          end
-          if servers && !servers.compact.empty?
+          server = try_select_server(cluster)
+
+          if server
             unless cluster.topology.compatible?
               raise Error::UnsupportedFeatures, cluster.topology.compatibility_error.to_s
             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 = servers.first
-
-            if cluster.topology.single? &&
-              cluster.topology.replica_set_name &&
-              cluster.topology.replica_set_name != server.description.replica_set_name
-            then
-              msg = "Cluster topology specifies replica set name #{cluster.topology.replica_set_name}, but the server has replica set name #{server.description.replica_set_name || '<nil>'}"
-              raise Error::NoServerAvailable.new(self, cluster, msg)
-            end
-
             if session && session.starting_transaction? && cluster.sharded?
               session.pin(server)
             end
@@ -260,67 +280,106 @@ module Mongo
         raise e
       end
 
-      # Get the timeout for server selection.
-      #
-      # @example Get the server selection timeout, in seconds.
-      #   selector.server_selection_timeout
-      #
-      # @return [ Float ] The timeout.
+      # Tries to find a suitable server, returns the server if one is available
+      # or nil if there isn't a suitable server.
       #
-      # @since 2.0.0
+      # @return [ Server | nil ] A suitable server, if one exists.
       #
-      # @deprecated This setting is now taken from the cluster options when a server is selected.
-      #   Will be removed in 3.0.
-      def server_selection_timeout
-        @server_selection_timeout ||=
-          (options[:server_selection_timeout] || ServerSelector::SERVER_SELECTION_TIMEOUT)
-      end
+      # @api private
+      def try_select_server(cluster)
+        servers = suitable_servers(cluster)
 
-      def local_threshold_with_cluster(cluster)
-        options[:local_threshold] || cluster.options[:local_threshold] || LOCAL_THRESHOLD
+        # 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 = servers.first
+
+        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
+        end
+
+        server
       end
 
-      # Get the local threshold boundary for nearest selection in seconds.
+      # Returns servers of acceptable types from the cluster.
       #
-      # @example Get the local threshold.
-      #   selector.local_threshold
+      # Does not perform staleness validation, staleness filtering or
+      # latency filtering.
       #
-      # @return [ Float ] The local threshold.
+      # @param [ Cluster ] cluster The cluster.
       #
-      # @since 2.0.0
+      # @return [ Array<Server> ] The candidate servers.
       #
-      # @deprecated This setting is now taken from the cluster options when a server is selected.
-      #   Will be removed in 3.0.
-      def local_threshold
-        @local_threshold ||= (options[:local_threshold] || ServerSelector::LOCAL_THRESHOLD)
+      # @api private
+      def candidates(cluster)
+        servers = cluster.servers
+        servers.each do |server|
+          validate_max_staleness_support!(server)
+        end
+        if cluster.single?
+          servers
+        elsif cluster.sharded?
+          servers
+        elsif cluster.replica_set?
+          select_in_replica_set(servers)
+        else
+          # Unknown cluster - no servers
+          []
+        end
       end
 
-      # Get the potential candidates to select from the cluster.
-      #
-      # @example Get the server candidates.
-      #   selectable.candidates(cluster)
+      # Returns servers satisfying the server selector from the cluster.
       #
       # @param [ Cluster ] cluster The cluster.
       #
-      # @return [ Array<Server> ] The candidate servers.
+      # @return [ Array<Server> ] The suitable servers.
       #
-      # @since 2.4.0
-      def candidates(cluster)
+      # @api private
+      def suitable_servers(cluster)
         if cluster.single?
-          cluster.servers.each { |server| validate_max_staleness_support!(server) }
+          candidates(cluster)
         elsif cluster.sharded?
           local_threshold = local_threshold_with_cluster(cluster)
-          near_servers(cluster.servers, local_threshold).each do |server|
-            validate_max_staleness_support!(server)
-          end
+          servers = candidates(cluster)
+          near_servers(servers, local_threshold)
+        elsif cluster.replica_set?
+          validate_max_staleness_value!(cluster)
+          candidates(cluster)
         else
-          validate_max_staleness_value!(cluster) unless cluster.unknown?
-          select(cluster.servers)
+          # Unknown cluster - no servers
+          []
         end
       end
 
       private
 
+      # Convert this server preference definition into a format appropriate
+      #   for sending to a MongoDB server (i.e., as a command field).
+      #
+      # @return [ Hash ] The server preference formatted as a command field value.
+      #
+      # @since 2.0.0
+      def full_doc
+        @full_doc ||= begin
+          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
+          preference
+        end
+      end
+
       # Select the primary from a list of provided candidates.
       #
       # @param [ Array ] candidates List of candidate servers to select the
@@ -445,6 +504,20 @@ module Mongo
         elsif @max_staleness && !max_staleness_allowed?
           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
 
       def validate_max_staleness_support!(server)