mongo 2.20.1 → 2.21.1

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.

data/lib/mongo/session/server_session/dirtyable.rb

@@ -19,7 +19,7 @@ module Mongo
     class ServerSession
       # Functionality for manipulating and querying a session's
       # "dirty" state, per the last paragraph at
-      # https://github.com/mongodb/specifications/blob/master/source/sessions/driver-sessions.rst#server-session-pool
+      # https://github.com/mongodb/specifications/blob/master/source/sessions/driver-sessions.md#server-session-pool
       #
       #   If a driver has a server session pool and a network error is
       #   encountered when executing any command with a ClientSession, the

data/lib/mongo/session.rb

@@ -57,6 +57,12 @@ module Mongo
     #
     # @option options [ true|false ] :causal_consistency Whether to enable
     #   causal consistency for this session.
+    # @option options [ Integer ] :default_timeout_ms The timeoutMS value for
+    #   the following operations executed on the session:
+    #   - commitTransaction
+    #   - abortTransaction
+    #   - withTransaction
+    #   - endSession
     # @option options [ Hash ] :default_transaction_options Options to pass
     #   to start_transaction by default, can contain any of the options that
     #   start_transaction accepts.
@@ -96,6 +102,7 @@ module Mongo
       @options = options.dup.freeze
       @cluster_time = nil
       @state = NO_TRANSACTION_STATE
+      @with_transaction_deadline = nil
     end
 
     # @return [ Hash ] The options for this session.
@@ -438,9 +445,21 @@ module Mongo
     #   progress or if the write concern is unacknowledged.
     #
     # @since 2.7.0
-    def with_transaction(options=nil)
-      # Non-configurable 120 second timeout for the entire operation
-      deadline = Utils.monotonic_time + 120
+    def with_transaction(options = nil)
+      if timeout_ms = (options || {})[:timeout_ms]
+        timeout_sec = timeout_ms / 1_000.0
+        deadline = Utils.monotonic_time + timeout_sec
+        @with_transaction_deadline = deadline
+      elsif default_timeout_ms = @options[:default_timeout_ms]
+        timeout_sec = default_timeout_ms / 1_000.0
+        deadline = Utils.monotonic_time + timeout_sec
+        @with_transaction_deadline = deadline
+      elsif @client.timeout_sec
+        deadline = Utils.monotonic_time + @client.timeout_sec
+        @with_transaction_deadline = deadline
+      else
+        deadline = Utils.monotonic_time + 120
+      end
       transaction_in_progress = false
       loop do
         commit_options = {}
@@ -454,6 +473,7 @@ module Mongo
         rescue Exception => e
           if within_states?(STARTING_TRANSACTION_STATE, TRANSACTION_IN_PROGRESS_STATE)
             log_warn("Aborting transaction due to #{e.class}: #{e}")
+            @with_transaction_deadline = nil
             abort_transaction
             transaction_in_progress = false
           end
@@ -481,7 +501,7 @@ module Mongo
           rescue Mongo::Error => e
             if e.label?('UnknownTransactionCommitResult')
               if Utils.monotonic_time >= deadline ||
-                e.is_a?(Error::OperationFailure) && e.max_time_ms_expired?
+                e.is_a?(Error::OperationFailure::Family) && e.max_time_ms_expired?
               then
                 transaction_in_progress = false
                 raise
@@ -522,9 +542,10 @@ module Mongo
         log_warn('with_transaction callback broke out of with_transaction loop, aborting transaction')
         begin
           abort_transaction
-        rescue Error::OperationFailure, Error::InvalidTransactionOperation
+        rescue Error::OperationFailure::Family, Error::InvalidTransactionOperation
         end
       end
+      @with_transaction_deadline = nil
     end
 
     # Places subsequent operations in this session into a new transaction.
@@ -539,6 +560,7 @@ module Mongo
     #
     # @option options [ Integer ] :max_commit_time_ms The maximum amount of
     #   time to allow a single commitTransaction command to run, in milliseconds.
+    #   This options is deprecated, use :timeout_ms instead.
     # @option options [ Hash ] :read_concern The read concern options hash,
     #   with the following optional keys:
     #   - *:level* -- the read preference level as a symbol; valid values
@@ -549,6 +571,10 @@ module Mongo
     #   items:
     #   - *:mode* -- read preference specified as a symbol; the only valid value is
     #     *:primary*.
+    # @option options [ Integer ] :timeout_ms The operation timeout in milliseconds.
+    #    Must be a non-negative integer. An explicit value of 0 means infinite.
+    #    The default value is unset which means the value is inherited from
+    #    the client.
     #
     # @raise [ Error::InvalidTransactionOperation ] If a transaction is already in
     #   progress or if the write concern is unacknowledged.
@@ -611,6 +637,10 @@ module Mongo
     #
     # @option options :write_concern [ nil | WriteConcern::Base ] The write
     #   concern to use for this operation.
+    # @option options [ Integer ] :timeout_ms The operation timeout in milliseconds.
+    #    Must be a non-negative integer. An explicit value of 0 means infinite.
+    #    The default value is unset which means the value is inherited from
+    #    the client.
     #
     # @raise [ Error::InvalidTransactionOperation ] If there is no active transaction.
     #
@@ -647,7 +677,11 @@ module Mongo
             write_concern = WriteConcern.get(write_concern)
           end
 
-          context = Operation::Context.new(client: @client, session: self)
+          context = Operation::Context.new(
+            client: @client,
+            session: self,
+            operation_timeouts: operation_timeouts(options)
+          )
           write_with_retry(write_concern, ending_transaction: true,
             context: context,
           ) do |connection, txn_num, context|
@@ -685,10 +719,15 @@ module Mongo
     # @example Abort the transaction.
     #   session.abort_transaction
     #
+    # @option options [ Integer ] :timeout_ms The operation timeout in milliseconds.
+    #    Must be a non-negative integer. An explicit value of 0 means infinite.
+    #    The default value is unset which means the value is inherited from
+    #    the client.
+    #
     # @raise [ Error::InvalidTransactionOperation ] If there is no active transaction.
     #
     # @since 2.6.0
-    def abort_transaction
+    def abort_transaction(options = nil)
       QueryCache.clear
 
       check_if_ended!
@@ -705,10 +744,16 @@ module Mongo
           Mongo::Error::InvalidTransactionOperation.cannot_call_twice_msg(:abortTransaction))
       end
 
+      options ||= {}
+
       begin
         unless starting_transaction?
           @aborting_transaction = true
-          context = Operation::Context.new(client: @client, session: self)
+          context = Operation::Context.new(
+            client: @client,
+            session: self,
+            operation_timeouts: operation_timeouts(options)
+          )
           write_with_retry(txn_options[:write_concern],
             ending_transaction: true, context: context,
           ) do |connection, txn_num, context|
@@ -898,7 +943,7 @@ module Mongo
     #
     # @since 2.6.0
     # @api private
-    def add_txn_opts!(command, read)
+    def add_txn_opts!(command, read, context)
       command.tap do |c|
         # The read concern should be added to any command that starts a transaction.
         if starting_transaction?
@@ -952,6 +997,14 @@ module Mongo
         if c[:writeConcern] && c[:writeConcern][:w] && c[:writeConcern][:w].is_a?(Symbol)
           c[:writeConcern][:w] = c[:writeConcern][:w].to_s
         end
+
+        # Ignore wtimeout if csot
+        if context&.csot?
+          c[:writeConcern]&.delete(:wtimeout)
+        end
+
+        # We must not send an empty (server default) write concern.
+        c.delete(:writeConcern) if c[:writeConcern]&.empty?
       end
     end
 
@@ -1138,6 +1191,8 @@ module Mongo
     # @api private
     attr_accessor :snapshot_timestamp
 
+    attr_reader :with_transaction_deadline
+
     private
 
     # Get the read concern the session will use when starting a transaction.
@@ -1217,5 +1272,19 @@ module Mongo
         end
       end
     end
+
+    def operation_timeouts(opts)
+      {
+        inherited_timeout_ms: @client.timeout_ms
+      }.tap do |result|
+        if @with_transaction_deadline.nil?
+          if timeout_ms = opts[:timeout_ms]
+            result[:operation_timeout_ms] = timeout_ms
+          elsif default_timeout_ms = options[:default_timeout_ms]
+            result[:operation_timeout_ms] = default_timeout_ms
+          end
+        end
+      end
+    end
   end
 end

data/lib/mongo/socket/ssl.rb

@@ -142,26 +142,37 @@ module Mongo
       #
       # @since 2.0.0
       def connect!
-        Timeout.timeout(options[:connect_timeout], Error::SocketTimeoutError, "The socket took over #{options[:connect_timeout]} seconds to connect") do
-          map_exceptions do
-            @tcp_socket.connect(::Socket.pack_sockaddr_in(port, host))
-          end
-          @socket = OpenSSL::SSL::SSLSocket.new(@tcp_socket, context)
-          begin
-            @socket.hostname = @host_name
-            @socket.sync_close = true
-            map_exceptions do
-              @socket.connect
+        sockaddr = ::Socket.pack_sockaddr_in(port, host)
+        connect_timeout = options[:connect_timeout]
+        map_exceptions do
+          if connect_timeout && connect_timeout != 0
+            deadline = Utils.monotonic_time + connect_timeout
+            if BSON::Environment.jruby?
+              # We encounter some strange problems with connect_nonblock for
+              # ssl sockets on JRuby. Therefore, we use the old +Timeout.timeout+
+              # solution, even though it is known to be not very reliable.
+              raise Error::SocketTimeoutError, 'connect_timeout expired' if connect_timeout < 0
+
+              Timeout.timeout(connect_timeout, Error::SocketTimeoutError, "The socket took over #{options[:connect_timeout]} seconds to connect") do
+                connect_without_timeout(sockaddr)
+              end
+            else
+              connect_with_timeout(sockaddr, connect_timeout)
             end
+            remaining_timeout = deadline - Utils.monotonic_time
+            verify_certificate!(@socket)
+            verify_ocsp_endpoint!(@socket, remaining_timeout)
+          else
+            connect_without_timeout(sockaddr)
             verify_certificate!(@socket)
             verify_ocsp_endpoint!(@socket)
-          rescue
-            @socket.close
-            @socket = nil
-            raise
           end
-          self
         end
+        self
+      rescue
+        @socket&.close
+        @socket = nil
+        raise
       end
       private :connect!
 
@@ -182,6 +193,87 @@ module Mongo
 
       private
 
+      # Connects the socket without a timeout provided.
+      #
+      # @param [ String ] sockaddr Address to connect to.
+      def connect_without_timeout(sockaddr)
+        @tcp_socket.connect(sockaddr)
+        @socket = OpenSSL::SSL::SSLSocket.new(@tcp_socket, context)
+        @socket.hostname = @host_name
+        @socket.sync_close = true
+        @socket.connect
+      end
+
+      # Connects the socket with the connect timeout. The timeout applies to
+      # connecting both ssl socket and the underlying tcp socket.
+      #
+      # @param [ String ] sockaddr Address to connect to.
+      def connect_with_timeout(sockaddr, connect_timeout)
+        if connect_timeout <= 0
+          raise Error::SocketTimeoutError, "The socket took over #{connect_timeout} seconds to connect"
+        end
+
+        deadline = Utils.monotonic_time + connect_timeout
+        connect_tcp_socket_with_timeout(sockaddr, deadline, connect_timeout)
+        connnect_ssl_socket_with_timeout(deadline, connect_timeout)
+      end
+
+      def connect_tcp_socket_with_timeout(sockaddr, deadline, connect_timeout)
+        if deadline <= Utils.monotonic_time
+          raise Error::SocketTimeoutError, "The socket took over #{connect_timeout} seconds to connect"
+        end
+        begin
+          @tcp_socket.connect_nonblock(sockaddr)
+        rescue IO::WaitWritable
+          with_select_timeout(deadline, connect_timeout) do |select_timeout|
+            IO.select(nil, [@tcp_socket], nil, select_timeout)
+          end
+          retry
+        rescue Errno::EISCONN
+          # Socket is connected, nothing to do.
+        end
+      end
+
+      def connnect_ssl_socket_with_timeout(deadline, connect_timeout)
+        if deadline <= Utils.monotonic_time
+          raise Error::SocketTimeoutError, "The socket took over #{connect_timeout} seconds to connect"
+        end
+        @socket = OpenSSL::SSL::SSLSocket.new(@tcp_socket, context)
+        @socket.hostname = @host_name
+        @socket.sync_close = true
+
+        # We still have time, connecting ssl socket.
+        begin
+          @socket.connect_nonblock
+        rescue IO::WaitReadable, OpenSSL::SSL::SSLErrorWaitReadable
+          with_select_timeout(deadline, connect_timeout) do |select_timeout|
+            IO.select([@socket], nil, nil, select_timeout)
+          end
+          retry
+        rescue IO::WaitWritable, OpenSSL::SSL::SSLErrorWaitWritable
+          with_select_timeout(deadline, connect_timeout) do |select_timeout|
+            IO.select(nil, [@socket], nil, select_timeout)
+          end
+          retry
+        rescue Errno::EISCONN
+          # Socket is connected, nothing to do
+        end
+      end
+
+      # Raises +Error::SocketTimeoutError+ exception if deadline reached or the
+      # block returns nil. The block should call +IO.select+ with the
+      # +connect_timeout+ value. It returns nil if the +connect_timeout+ expires.
+      def with_select_timeout(deadline, connect_timeout, &block)
+        select_timeout = deadline - Utils.monotonic_time
+        if select_timeout <= 0
+          raise Error::SocketTimeoutError, "The socket took over #{connect_timeout} seconds to connect"
+        end
+        rv = block.call(select_timeout)
+        if rv.nil?
+          raise Error::SocketTimeoutError, "The socket took over #{connect_timeout} seconds to connect"
+        end
+      end
+
       def verify_certificate?
         # If ssl_verify_certificate is not present, disable only if
         # ssl_verify is explicitly set to false.
@@ -362,7 +454,7 @@ module Mongo
         end
       end
 
-      def verify_ocsp_endpoint!(socket)
+      def verify_ocsp_endpoint!(socket, timeout = nil)
         unless verify_ocsp_endpoint?
           return
         end
@@ -371,7 +463,7 @@ module Mongo
         ca_cert = socket.peer_cert_chain.last
 
         verifier = OcspVerifier.new(@host_name, cert, ca_cert, context.cert_store,
-          **Utils.shallow_symbolize_keys(options))
+          **Utils.shallow_symbolize_keys(options).merge(timeout: timeout))
         verifier.verify_with_cache
       end
 

data/lib/mongo/socket/tcp.rb

@@ -79,16 +79,50 @@ module Mongo
       # @return [ TCP ] The connected socket instance.
       #
       # @since 2.0.0
+      # @api private
       def connect!
-        Timeout.timeout(options[:connect_timeout], Error::SocketTimeoutError, "The socket took over #{options[:connect_timeout]} seconds to connect") do
-          socket.setsockopt(IPPROTO_TCP, TCP_NODELAY, 1)
-          map_exceptions do
-            socket.connect(::Socket.pack_sockaddr_in(port, host))
+        socket.setsockopt(IPPROTO_TCP, TCP_NODELAY, 1)
+        sockaddr = ::Socket.pack_sockaddr_in(port, host)
+        connect_timeout = options[:connect_timeout]
+        map_exceptions do
+          if connect_timeout && connect_timeout != 0
+            connect_with_timeout(sockaddr, connect_timeout)
+          else
+            connect_without_timeout(sockaddr)
+          end
+        end
+        self
+      end
+
+      # @api private
+      def connect_without_timeout(sockaddr)
+        socket.connect(sockaddr)
+      end
+
+      # @api private
+      def connect_with_timeout(sockaddr, connect_timeout)
+        if connect_timeout <= 0
+          raise Error::SocketTimeoutError, "The socket took over #{connect_timeout} seconds to connect"
+        end
+
+        deadline = Utils.monotonic_time + connect_timeout
+        begin
+          socket.connect_nonblock(sockaddr)
+        rescue IO::WaitWritable
+          select_timeout = deadline - Utils.monotonic_time
+          if select_timeout <= 0
+            raise Error::SocketTimeoutError, "The socket took over #{connect_timeout} seconds to connect"
+          end
+          if IO.select(nil, [socket], nil, select_timeout)
+            retry
+          else
+            socket.close
+            raise Error::SocketTimeoutError, "The socket took over #{connect_timeout} seconds to connect"
           end
-          self
+        rescue Errno::EISCONN
+          # Socket is connected, nothing more to do
         end
       end
-      private :connect!
 
       private