mongo 2.20.0 → 2.21.0

data/lib/mongo/server/connection_base.rb

@@ -169,6 +169,7 @@ module Mongo
           raise Error::LintError, "Trying to deliver a message over a disconnected connection (to #{address})"
         end
         buffer = serialize(message, context)
+        check_timeout!(context)
         ensure_connected do |socket|
           operation_id = Monitoring.next_operation_id
           started_event = command_started(address, operation_id, message.payload,
@@ -181,9 +182,10 @@ module Mongo
           result = nil
           begin
             result = add_server_diagnostics do
-              socket.write(buffer.to_s)
+              socket.write(buffer.to_s, timeout: context.remaining_timeout_sec)
               if message.replyable?
-                Protocol::Message.deserialize(socket, max_message_size, message.request_id, options)
+                check_timeout!(context)
+                Protocol::Message.deserialize(socket, max_message_size, message.request_id, options.merge(timeout: context.remaining_timeout_sec))
               else
                 nil
               end
@@ -273,6 +275,24 @@ module Mongo
 
         buffer
       end
+
+      # If timeoutMS is set for the operation context, checks whether there is
+      # enough time left to send the corresponding message to the server
+      # (remaining timeout is bigger than minimum round trip time for
+      # the server)
+      #
+      # @param [ Mongo::Operation::Context ] context Context of the operation.
+      #
+      # @raise [ Mongo::Error::TimeoutError ] if timeout expired or there is
+      #   not enough time to send the message to the server.
+      def check_timeout!(context)
+        return if [nil, 0].include?(context.deadline)
+
+        time_to_execute = context.remaining_timeout_sec - server.minimum_round_trip_time
+        if time_to_execute <= 0
+          raise Mongo::Error::TimeoutError
+        end
+      end
     end
   end
 end

data/lib/mongo/server/connection_pool.rb

@@ -205,11 +205,18 @@ module Mongo
 
       # The time to wait, in seconds, for a connection to become available.
       #
+      # @param [ Mongo::Operation:Context | nil ] context Context of the operation
+      #   the connection is requested for, if any.
+      #
       # @return [ Float ] The queue wait timeout.
       #
       # @since 2.9.0
-      def wait_timeout
-        @wait_timeout ||= options[:wait_timeout] || DEFAULT_WAIT_TIMEOUT
+      def wait_timeout(context = nil)
+        if context&.remaining_timeout_sec.nil?
+          options[:wait_timeout] || DEFAULT_WAIT_TIMEOUT
+        else
+          context&.remaining_timeout_sec
+        end
       end
 
       # The maximum seconds a socket can remain idle since it has been
@@ -345,6 +352,10 @@ module Mongo
       # The returned connection counts toward the pool's max size. When the
       # caller is finished using the connection, the connection should be
       # checked back in via the check_in method.
+      # @param [ Integer | nil ] :connection_global_id The global id for the
+      #   connection to check out.
+      # @param [ Mongo::Operation:Context | nil ] :context Context of the operation
+      #   the connection is requested for, if any.
       #
       # @return [ Mongo::Server::Connection ] The checked out connection.
       # @raise [ Error::PoolClosedError ] If the pool has been closed.
@@ -352,7 +363,7 @@ module Mongo
       #   and remains so for longer than the wait timeout.
       #
       # @since 2.9.0
-      def check_out(connection_global_id: nil)
+      def check_out(connection_global_id: nil, context: nil)
         check_invariants
 
         publish_cmap_event(
@@ -362,7 +373,9 @@ module Mongo
         raise_if_pool_closed!
         raise_if_pool_paused_locked!
 
-        connection = retrieve_and_connect_connection(connection_global_id)
+        connection = retrieve_and_connect_connection(
+          connection_global_id, context
+        )
 
         publish_cmap_event(
           Monitoring::Event::Cmap::ConnectionCheckedOut.new(@server.address, connection.id, self),
@@ -698,10 +711,13 @@ module Mongo
       # @return [ Object ] The result of the block.
       #
       # @since 2.0.0
-      def with_connection(connection_global_id: nil)
+      def with_connection(connection_global_id: nil, context: nil)
         raise_if_closed!
 
-        connection = check_out(connection_global_id: connection_global_id)
+        connection = check_out(
+          connection_global_id: connection_global_id,
+          context: context
+        )
         yield(connection)
       rescue Error::SocketError, Error::SocketTimeoutError, Error::ConnectionPerished => e
         maybe_raise_pool_cleared!(connection, e)
@@ -975,9 +991,9 @@ module Mongo
 
       # Attempts to connect (handshake and auth) the connection. If an error is
       # encountered, closes the connection and raises the error.
-      def connect_connection(connection)
+      def connect_connection(connection, context = nil)
         begin
-          connection.connect!
+          connection.connect!(context)
         rescue Exception
           connection.disconnect!(reason: :error)
           raise
@@ -1242,16 +1258,18 @@ module Mongo
 
       # Retrieves a connection and connects it.
       #
-      # @param [ Integer ] connection_global_id The global id for the
+      # @param [ Integer | nil ] connection_global_id The global id for the
       #   connection to check out.
+      # @param [ Mongo::Operation:Context | nil ] context Context of the operation
+      #   the connection is requested for, if any.
       #
       # @return [ Mongo::Server::Connection ] The checked out connection.
       #
       # @raise [ Error::PoolClosedError ] If the pool has been closed.
       # @raise [ Timeout::Error ] If the connection pool is at maximum size
       #   and remains so for longer than the wait timeout.
-      def retrieve_and_connect_connection(connection_global_id)
-        deadline = Utils.monotonic_time + wait_timeout
+      def retrieve_and_connect_connection(connection_global_id, context =  nil)
+        deadline = Utils.monotonic_time + wait_timeout(context)
         connection = nil
 
         @lock.synchronize do
@@ -1267,7 +1285,7 @@ module Mongo
           connection = wait_for_connection(connection_global_id, deadline)
         end
 
-        connect_or_raise(connection) unless connection.connected?
+        connect_or_raise(connection, context) unless connection.connected?
 
         @lock.synchronize do
           @checked_out_connections << connection
@@ -1327,8 +1345,8 @@ module Mongo
       # cannot be connected.
       # This method also publish corresponding event and ensures that counters
       # and condition variables are updated.
-      def connect_or_raise(connection)
-        connect_connection(connection)
+      def connect_or_raise(connection, context)
+        connect_connection(connection, context)
       rescue Exception
         # Handshake or authentication failed
         @lock.synchronize do

data/lib/mongo/server/description/features.rb

@@ -83,7 +83,7 @@ module Mongo
         # The wire protocol versions that this version of the driver supports.
         #
         # @since 2.0.0
-        DRIVER_WIRE_VERSIONS = (6..21).freeze
+        DRIVER_WIRE_VERSIONS = (6..25).freeze
 
         # Create the methods for each mapping to tell if they are supported.
         #

data/lib/mongo/server/description.rb

@@ -209,8 +209,8 @@ module Mongo
       # @param [ Hash ] config The result of the hello command.
       # @param [ Float ] average_round_trip_time The moving average time (sec) the hello
       #   command took to complete.
-      # @param [ Float ] average_round_trip_time The moving average time (sec)
-      #   the ismaster call took to complete.
+      # @param [ Float ] minimum_round_trip_time The minimum round trip time
+      #   of ten last hello commands.
       # @param [ true | false ] load_balancer Whether the server is treated as
       #   a load balancer.
       # @param [ true | false ] force_load_balancer Whether the server is
@@ -218,7 +218,8 @@ module Mongo
       #
       # @api private
       def initialize(address, config = {}, average_round_trip_time: nil,
-        load_balancer: false, force_load_balancer: false
+        minimum_round_trip_time: 0, load_balancer: false,
+        force_load_balancer: false
       )
         @address = address
         @config = config
@@ -226,6 +227,7 @@ module Mongo
         @force_load_balancer = !!force_load_balancer
         @features = Features.new(wire_versions, me || @address.to_s)
         @average_round_trip_time = average_round_trip_time
+        @minimum_round_trip_time = minimum_round_trip_time
         @last_update_time = Time.now.freeze
         @last_update_monotime = Utils.monotonic_time
 
@@ -302,6 +304,10 @@ module Mongo
       # @return [ Float ] The moving average time the hello call took to complete.
       attr_reader :average_round_trip_time
 
+      # @return [ Float ] The minimum time from the ten last hello calls took
+      #   to complete.
+      attr_reader :minimum_round_trip_time
+
       # Returns whether this server is an arbiter, per the SDAM spec.
       #
       # @example Is the server an arbiter?
@@ -723,8 +729,7 @@ module Mongo
 
       # @api private
       def ok?
-        config[Operation::Result::OK] &&
-          config[Operation::Result::OK] == 1 || false
+        config[Operation::Result::OK] == 1
       end
 
       # Get the range of supported wire versions for the server.
@@ -802,6 +807,14 @@ module Mongo
         !!(address.to_s.downcase != me.downcase if me)
       end
 
+      # Whether this description is from a mongocryptd server.
+      #
+      # @return [ true, false ] Whether this description is from a mongocryptd
+      #   server.
+      def mongocryptd?
+        ok? && config['iscryptd'] == true
+      end
+
       # opTime in lastWrite subdocument of the hello response.
       #
       # @return [ BSON::Timestamp ] The timestamp.

data/lib/mongo/server/monitor.rb

@@ -237,8 +237,11 @@ module Mongo
         @sdam_mutex.synchronize do
           old_description = server.description
 
-          new_description = Description.new(server.address, result,
-            average_round_trip_time: server.round_trip_time_averager.average_round_trip_time
+          new_description = Description.new(
+            server.address,
+            result,
+            average_round_trip_time: server.round_trip_time_calculator.average_round_trip_time,
+            minimum_round_trip_time: server.round_trip_time_calculator.minimum_round_trip_time
           )
 
           server.cluster.run_sdam_flow(server.description, new_description, awaited: awaited, scan_error: scan_error)
@@ -306,7 +309,7 @@ module Mongo
         end
 
         if @connection
-          result = server.round_trip_time_averager.measure do
+          result = server.round_trip_time_calculator.measure do
             begin
               doc = @connection.check_document
               cmd = Protocol::Query.new(
@@ -323,7 +326,7 @@ module Mongo
         else
           connection = Connection.new(server.address, options)
           connection.connect!
-          result = server.round_trip_time_averager.measure do
+          result = server.round_trip_time_calculator.measure do
             connection.handshake!
           end
           @connection = connection

data/lib/mongo/server/pending_connection.rb

@@ -110,6 +110,24 @@ module Mongo
 
       private
 
+      # Sends the hello command to the server, then receive and deserialize
+      # the response.
+      #
+      # This method is extracted to be mocked in the tests.
+      #
+      # @param [ Protocol::Message ] Command that should be sent to a server
+      #   for handshake purposes.
+      #
+      # @return [ Mongo::Protocol::Reply ] Deserialized server response.
+      def get_handshake_response(hello_command)
+        @server.round_trip_time_calculator.measure do
+          add_server_diagnostics do
+            socket.write(hello_command.serialize.to_s)
+            Protocol::Message.deserialize(socket, Protocol::Message::MAX_MESSAGE_SIZE)
+          end
+        end
+      end
+
       # @param [ BSON::Document | nil ] speculative_auth_doc The document to
       #   provide in speculativeAuthenticate field of handshake command.
       #
@@ -131,12 +149,7 @@ module Mongo
         doc = nil
         @server.handle_handshake_failure! do
           begin
-            response = @server.round_trip_time_averager.measure do
-              add_server_diagnostics do
-                socket.write(hello_command.serialize.to_s)
-                Protocol::Message.deserialize(socket, Protocol::Message::MAX_MESSAGE_SIZE)
-              end
-            end
+            response = get_handshake_response(hello_command)
             result = Operation::Result.new([response])
             result.validate!
             doc = result.documents.first
@@ -155,7 +168,11 @@ module Mongo
           doc['serviceId'] ||= "fake:#{rand(2**32-1)+1}"
         end
 
-        post_handshake(doc, @server.round_trip_time_averager.average_round_trip_time)
+        post_handshake(
+          doc,
+          @server.round_trip_time_calculator.average_round_trip_time,
+          @server.round_trip_time_calculator.minimum_round_trip_time
+        )
 
         doc
       end
@@ -205,7 +222,7 @@ module Mongo
       #
       # @return [ Server::Description ] The server description calculated from
       #   the handshake response for this particular connection.
-      def post_handshake(response, average_rtt)
+      def post_handshake(response, average_rtt, minimum_rtt)
         if response["ok"] == 1
           # Auth mechanism is entirely dependent on the contents of
           # hello response *for this connection*.

data/lib/mongo/server/{round_trip_time_averager.rb → round_trip_time_calculator.rb}

@@ -18,20 +18,30 @@
 module Mongo
   class Server
     # @api private
-    class RoundTripTimeAverager
+    class RoundTripTimeCalculator
 
       # The weighting factor (alpha) for calculating the average moving
       # round trip time.
       RTT_WEIGHT_FACTOR = 0.2.freeze
       private_constant :RTT_WEIGHT_FACTOR
 
+      RTT_SAMPLES_FOR_MINIMUM = 10
+      private_constant :RTT_SAMPLES_FOR_MINIMUM
+
+      MIN_SAMPLES = 3
+      private_constant :MIN_SAMPLES
+
       def initialize
         @last_round_trip_time = nil
         @average_round_trip_time = nil
+        @minimum_round_trip_time = 0
+        @lock = Mutex.new
+        @rtts = []
       end
 
       attr_reader :last_round_trip_time
       attr_reader :average_round_trip_time
+      attr_reader :minimum_round_trip_time
 
       def measure
         start = Utils.monotonic_time
@@ -44,14 +54,17 @@ module Mongo
         rescue Error, Error::AuthError => exc
           # For other errors, RTT is valid.
         end
-        last_round_trip_time = Utils.monotonic_time - start
+        last_rtt = Utils.monotonic_time - start
 
         # If hello fails, we need to return the last round trip time
         # because it is used in the heartbeat failed SDAM event,
         # but we must not update the round trip time recorded in the server.
         unless exc
-          @last_round_trip_time = last_round_trip_time
-          update_average_round_trip_time
+          @last_round_trip_time = last_rtt
+          @lock.synchronize do
+            update_average_round_trip_time
+            update_minimum_round_trip_time
+          end
         end
 
         if exc
@@ -61,9 +74,6 @@ module Mongo
         end
       end
 
-      private
-
-      # This method is separate for testing purposes.
       def update_average_round_trip_time
         @average_round_trip_time = if average_round_trip_time
           RTT_WEIGHT_FACTOR * last_round_trip_time + (1 - RTT_WEIGHT_FACTOR) * average_round_trip_time
@@ -71,6 +81,14 @@ module Mongo
           last_round_trip_time
         end
       end
+
+      def update_minimum_round_trip_time
+        @rtts.push(last_round_trip_time) unless last_round_trip_time.nil?
+        @minimum_round_trip_time = 0 and return if @rtts.size < MIN_SAMPLES
+
+        @rtts.shift if @rtts.size > RTT_SAMPLES_FOR_MINIMUM
+        @minimum_round_trip_time = @rtts.compact.min
+      end
     end
   end
 end

data/lib/mongo/server.rb

@@ -80,7 +80,7 @@ module Mongo
         include Id
       end
       @scan_semaphore = DistinguishingSemaphore.new
-      @round_trip_time_averager = RoundTripTimeAverager.new
+      @round_trip_time_calculator = RoundTripTimeCalculator.new
       @description = Description.new(address, {},
         load_balancer: !!@options[:load_balancer],
         force_load_balancer: force_load_balancer?,
@@ -197,6 +197,7 @@ module Mongo
                    :max_message_size,
                    :tags,
                    :average_round_trip_time,
+                   :minimum_round_trip_time,
                    :mongos?,
                    :other?,
                    :primary?,
@@ -228,9 +229,9 @@ module Mongo
     # @api private
     attr_reader :scan_semaphore
 
-    # @return [ RoundTripTimeAverager ] Round trip time averager object.
+    # @return [ RoundTripTimeCalculator ] Round trip time calculator object.
     # @api private
-    attr_reader :round_trip_time_averager
+    attr_reader :round_trip_time_calculator
 
     # Is this server equal to another?
     #
@@ -490,8 +491,12 @@ module Mongo
     # @return [ Object ] The result of the block execution.
     #
     # @since 2.3.0
-    def with_connection(connection_global_id: nil, &block)
-      pool.with_connection(connection_global_id: connection_global_id, &block)
+    def with_connection(connection_global_id: nil, context: nil, &block)
+      pool.with_connection(
+        connection_global_id: connection_global_id,
+        context: context,
+        &block
+      )
     end
 
     # Handle handshake failure.
@@ -697,5 +702,5 @@ require 'mongo/server/connection'
 require 'mongo/server/connection_pool'
 require 'mongo/server/description'
 require 'mongo/server/monitor'
-require 'mongo/server/round_trip_time_averager'
+require 'mongo/server/round_trip_time_calculator'
 require 'mongo/server/push_monitor'

data/lib/mongo/server_selector/base.rb

@@ -33,11 +33,11 @@ module Mongo
       #
       # @option options [ Integer ] :local_threshold The local threshold boundary for
       #  nearest selection in seconds.
-      # @option options [ Integer ] max_staleness The maximum replication lag,
+      # @option options [ Integer ] :max_staleness The maximum replication lag,
       #   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
+      # @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.
@@ -168,6 +168,8 @@ module Mongo
       #   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.
+      # @param [ Float | nil ] :timeout Timeout in seconds for the operation,
+      #   if any.
       #
       # @return [ Mongo::Server ] A server matching the server preference.
       #
@@ -178,21 +180,35 @@ module Mongo
       #   lint mode is enabled.
       #
       # @since 2.0.0
-      def select_server(cluster, ping = nil, session = nil, write_aggregation: false, deprioritized: [])
-        select_server_impl(cluster, ping, session, write_aggregation, deprioritized).tap do |server|
+      def select_server(
+        cluster,
+        ping = nil,
+        session = nil,
+        write_aggregation: false,
+        deprioritized: [],
+        timeout: nil
+      )
+        select_server_impl(cluster, ping, session, write_aggregation, deprioritized, timeout).tap do |server|
           if Lint.enabled? && !server.pool.ready?
             raise Error::LintError, 'Server selector returning a server with a pool which is not ready'
           end
         end
       end
 
-      # Parameters and return values are the same as for select_server.
-      private def select_server_impl(cluster, ping, session, write_aggregation, deprioritized)
+      # 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)
         if cluster.topology.is_a?(Cluster::Topology::LoadBalanced)
           return cluster.servers.first
         end
 
-        server_selection_timeout = cluster.options[:server_selection_timeout] || SERVER_SELECTION_TIMEOUT
+        timeout = cluster.options[:server_selection_timeout] || SERVER_SELECTION_TIMEOUT
+
+        server_selection_timeout = if csot_timeout && csot_timeout > 0
+                                     [timeout, csot_timeout].min
+                                   else
+                                     timeout
+                                   end
 
         # Special handling for zero timeout: if we have to select a server,
         # and the timeout is zero, fail immediately (since server selection
@@ -638,9 +654,9 @@ module Mongo
       # 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
+      # If the cluster does 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
+      # This functionality is provided for backwards compatibility 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.