mongo 2.19.1 → 2.21.0

data/lib/mongo/operation/result.rb

@@ -100,9 +100,13 @@ module Mongo
       # @param [ Integer ] connection_global_id
       #   Global id of the connection on which the operation that
       #   this result is for was performed.
+      # @param [ Operation::Context | nil ] context the context that was active
+      #   when this result was produced.
       #
       # @api private
-      def initialize(replies, connection_description = nil, connection_global_id = nil)
+      def initialize(replies, connection_description = nil, connection_global_id = nil, context: nil, connection: nil)
+        @context = context
+
         if replies
           if replies.is_a?(Array)
             if replies.length != 1
@@ -118,6 +122,7 @@ module Mongo
           @replies = [ reply ]
           @connection_description = connection_description
           @connection_global_id = connection_global_id
+          @connection = connection
         end
       end
 
@@ -138,6 +143,14 @@ module Mongo
       # @api private
       attr_reader :connection_global_id
 
+      # @return [ Operation::Context | nil ] the operation context (if any)
+      #   that was active when this result was produced.
+      #
+      # @api private
+      attr_reader :context
+
+      attr_reader :connection
+
       # @api private
       def_delegators :parser,
         :not_master?, :node_recovering?, :node_shutting_down?
@@ -320,7 +333,7 @@ module Mongo
       # @example Validate the result.
       #   result.validate!
       #
-      # @raise [ Error::OperationFailure ] If an error is in the result.
+      # @raise [ Error::OperationFailure::Family ] If an error is in the result.
       #
       # @return [ Result ] The result if verification passed.
       #
@@ -330,16 +343,16 @@ module Mongo
         !successful? ? raise_operation_failure : self
       end
 
-      # The exception instance (of the Error::OperationFailure class)
+      # The exception instance (of Error::OperationFailure::Family)
       # that would be raised during processing of this result.
       #
       # This method should only be called when result is not successful.
       #
-      # @return [ Error::OperationFailure ] The exception.
+      # @return [ Error::OperationFailure::Family ] The exception.
       #
       # @api private
       def error
-        @error ||= Error::OperationFailure.new(
+        @error ||= operation_failure_class.new(
           parser.message,
           self,
           code: parser.code,
@@ -453,6 +466,14 @@ module Mongo
 
       private
 
+      def operation_failure_class
+        if context&.csot? && parser.code == 50
+          Error::ServerTimeoutError
+        else
+          Error::OperationFailure
+        end
+      end
+
       def aggregate_returned_count
         replies.reduce(0) do |n, reply|
           n += reply.number_returned

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

@@ -15,6 +15,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+require 'mongo/error'
+
 module Mongo
   module Operation
 
@@ -26,44 +28,57 @@ module Mongo
 
       include ResponseHandling
 
+      # @return [ Operation::Context | nil ] the operation context used to
+      #   execute this operation.
+      attr_accessor :context
+
       def do_execute(connection, context, options = {})
+        # Save the context on the instance, to avoid having to pass it as a
+        # parameter to every single method. There are many legacy methods that
+        # still accept it as a parameter, which are left as-is for now to
+        # minimize the impact of this change. Moving forward, it may be
+        # reasonable to refactor things so this saved reference is used instead.
+        @context = context
+
         session&.materialize_if_needed
         unpin_maybe(session, connection) do
           add_error_labels(connection, context) do
-            add_server_diagnostics(connection) do
-              get_result(connection, context, options).tap do |result|
-                if session
-                  if session.in_transaction? &&
-                    connection.description.load_balancer?
-                  then
-                    if session.pinned_connection_global_id
-                      unless session.pinned_connection_global_id == connection.global_id
-                        raise(
-                          Error::InternalDriverError,
-                          "Expected operation to use connection #{session.pinned_connection_global_id} but it used #{connection.global_id}"
-                        )
+            check_for_network_error do
+              add_server_diagnostics(connection) do
+                get_result(connection, context, options).tap do |result|
+                  if session
+                    if session.in_transaction? &&
+                      connection.description.load_balancer?
+                    then
+                      if session.pinned_connection_global_id
+                        unless session.pinned_connection_global_id == connection.global_id
+                          raise(
+                            Error::InternalDriverError,
+                            "Expected operation to use connection #{session.pinned_connection_global_id} but it used #{connection.global_id}"
+                          )
+                        end
+                      else
+                        session.pin_to_connection(connection.global_id)
+                        connection.pin
                       end
-                    else
-                      session.pin_to_connection(connection.global_id)
-                      connection.pin
                     end
-                  end
 
-                  if session.snapshot? && !session.snapshot_timestamp
-                    session.snapshot_timestamp = result.snapshot_timestamp
+                    if session.snapshot? && !session.snapshot_timestamp
+                      session.snapshot_timestamp = result.snapshot_timestamp
+                    end
                   end
-                end
 
-                if result.has_cursor_id? &&
-                  connection.description.load_balancer?
-                then
-                  if result.cursor_id == 0
-                    connection.unpin
-                  else
-                    connection.pin
+                  if result.has_cursor_id? &&
+                    connection.description.load_balancer?
+                  then
+                    if result.cursor_id == 0
+                      connection.unpin
+                    else
+                      connection.pin
+                    end
                   end
+                  process_result(result, connection)
                 end
-                process_result(result, connection)
               end
             end
           end
@@ -89,7 +104,7 @@ module Mongo
       end
 
       def get_result(connection, context, options = {})
-        result_class.new(*dispatch_message(connection, context, options))
+        result_class.new(*dispatch_message(connection, context, options), context: context, connection: connection)
       end
 
       # Returns a Protocol::Message or nil as reply.
@@ -144,6 +159,18 @@ module Mongo
           connection.server.scan_semaphore.signal
         end
       end
+
+      NETWORK_ERRORS = [
+        Error::SocketError,
+        Error::SocketTimeoutError
+      ].freeze
+
+      def check_for_network_error
+        yield
+      rescue *NETWORK_ERRORS
+        session&.dirty!
+        raise
+      end
     end
   end
 end

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

@@ -32,7 +32,10 @@ module Mongo
       #
       # @return [ Mongo::Operation::Result ] The operation result.
       def execute(server, context:, options: {})
-        server.with_connection(connection_global_id: context.connection_global_id) do |connection|
+        server.with_connection(
+          connection_global_id: context.connection_global_id,
+          context: context
+        ) do |connection|
           execute_with_connection(connection, context: context, options: options)
         end
       end

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

@@ -42,7 +42,7 @@ module Mongo
       # Adds error labels to exceptions raised in the yielded to block,
       # which should perform MongoDB operations and raise Mongo::Errors on
       # failure. This method handles network errors (Error::SocketError)
-      # and server-side errors (Error::OperationFailure); it does not
+      # and server-side errors (Error::OperationFailure::Family); it does not
       # handle server selection errors (Error::NoServerAvailable), for which
       # labels are added in the server selection code.
       #
@@ -50,35 +50,33 @@ module Mongo
       #   the operation is performed.
       # @param [ Mongo::Operation::Context ] context The operation context.
       def add_error_labels(connection, context)
-        begin
-          yield
-        rescue Mongo::Error::SocketError => e
-          if context.in_transaction? && !context.committing_transaction?
-            e.add_label('TransientTransactionError')
-          end
-          if context.committing_transaction?
-            e.add_label('UnknownTransactionCommitResult')
-          end
+        yield
+      rescue Mongo::Error::SocketError => e
+        if context.in_transaction? && !context.committing_transaction?
+          e.add_label('TransientTransactionError')
+        end
+        if context.committing_transaction?
+          e.add_label('UnknownTransactionCommitResult')
+        end
 
-          maybe_add_retryable_write_error_label!(e, connection, context)
-
-          raise e
-        rescue Mongo::Error::SocketTimeoutError => e
-          maybe_add_retryable_write_error_label!(e, connection, context)
-          raise e
-        rescue Mongo::Error::OperationFailure => e
-          if context.committing_transaction?
-            if e.write_retryable? || e.wtimeout? || (e.write_concern_error? &&
-                !Session::UNLABELED_WRITE_CONCERN_CODES.include?(e.write_concern_error_code)
-            ) || e.max_time_ms_expired?
-              e.add_label('UnknownTransactionCommitResult')
-            end
+        maybe_add_retryable_write_error_label!(e, connection, context)
+
+        raise e
+      rescue Mongo::Error::SocketTimeoutError => e
+        maybe_add_retryable_write_error_label!(e, connection, context)
+        raise e
+      rescue Mongo::Error::OperationFailure::Family => e
+        if context.committing_transaction?
+          if e.write_retryable? || e.wtimeout? || (e.write_concern_error? &&
+              !Session::UNLABELED_WRITE_CONCERN_CODES.include?(e.write_concern_error_code)
+          ) || e.max_time_ms_expired?
+            e.add_label('UnknownTransactionCommitResult')
           end
+        end
 
-          maybe_add_retryable_write_error_label!(e, connection, context)
+        maybe_add_retryable_write_error_label!(e, connection, context)
 
-          raise e
-        end
+        raise e
       end
 
       # Unpins the session and/or the connection if  the yielded to block
@@ -106,7 +104,7 @@ module Mongo
       # raised during execution of operations on servers.
       def add_server_diagnostics(connection)
         yield
-      rescue Error::SocketError, Error::SocketTimeoutError
+      rescue Error::SocketError, Error::SocketTimeoutError, Error::TimeoutError
         # Diagnostics should have already been added by the connection code,
         # do not add them again.
         raise

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

@@ -114,7 +114,7 @@ module Mongo
       end
 
       def apply_txn_opts!(selector)
-        session.add_txn_opts!(selector, read_command?(selector))
+        session.add_txn_opts!(selector, read_command?(selector), context)
       end
 
       def suppress_read_write_concern!(selector)

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

@@ -260,6 +260,13 @@ module Mongo
         spec[INDEX]
       end
 
+      # Get the index id from the spec.
+      #
+      # @return [ String ] The index id.
+      def index_id
+        spec[:index_id]
+      end
+
       # Get the index name from the spec.
       #
       # @example Get the index name.

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Mongo
+  module Operation
+    # Defines the behavior of operations that have the default timeout
+    # behavior described by the client-side operation timeouts (CSOT)
+    # spec.
+    #
+    # @api private
+    module Timed
+      # If a timeout is active (as defined by the current context), and it has
+      # not yet expired, add :maxTimeMS to the spec.
+      #
+      # @param [ Hash ] spec The spec to modify
+      # @param [ Connection ] connection The connection that will be used to
+      #   execute the operation
+      #
+      # @return [ Hash ] the spec
+      #
+      # @raises [ Mongo::Error::TimeoutError ] if the current timeout has
+      #   expired.
+      def apply_relevant_timeouts_to(spec, connection)
+        with_max_time(connection) do |max_time_sec|
+          return spec if max_time_sec.nil?
+          return spec if connection.description.mongocryptd?
+
+          spec.tap { spec[:maxTimeMS] = (max_time_sec * 1_000).to_i }
+        end
+      end
+
+      # A helper method that computes the remaining timeout (in seconds) and
+      # yields it to the associated block. If no timeout is present, yields
+      # nil. If the timeout has expired, raises Mongo::Error::TimeoutError.
+      #
+      # @param [ Connection ] connection The connection that will be used to
+      #   execute the operation
+      #
+      # @return [ Hash ] the result of yielding to the block (which must be
+      #   a Hash)
+      def with_max_time(connection)
+        if context&.timeout?
+          max_time_sec = context.remaining_timeout_sec - connection.server.minimum_round_trip_time
+          raise Mongo::Error::TimeoutError if max_time_sec <= 0
+
+          yield max_time_sec
+        else
+          yield nil
+        end
+      end
+    end
+  end
+end

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

@@ -35,7 +35,10 @@ module Mongo
       #
       # @since 2.5.2
       def execute(server, context:)
-        server.with_connection(connection_global_id: context.connection_global_id) do |connection|
+        server.with_connection(
+          connection_global_id: context.connection_global_id,
+          context: context
+        ) do |connection|
           execute_with_connection(connection, context: context)
         end
       end

data/lib/mongo/operation/update/op_msg.rb

@@ -45,7 +45,8 @@ module Mongo
         def message(connection)
           updates = validate_updates(connection, send(IDENTIFIER))
           section = Protocol::Msg::Section1.new(IDENTIFIER, updates)
-          Protocol::Msg.new(flags, {}, command(connection), section)
+          cmd = apply_relevant_timeouts_to(command(connection), connection)
+          Protocol::Msg.new(flags, {}, cmd, section)
         end
       end
     end

data/lib/mongo/operation/update_search_index/op_msg.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Mongo
+  module Operation
+    class UpdateSearchIndex
+      # A MongoDB updateSearchIndex operation sent as an op message.
+      #
+      # @api private
+      class OpMsg < OpMsgBase
+        include ExecutableTransactionLabel
+
+        private
+
+        # Returns the command to send to the database, describing the
+        # desired updateSearchIndex operation.
+        #
+        # @param [ Connection ] _connection the connection that will receive the
+        #   command
+        #
+        # @return [ Hash ] the selector
+        def selector(_connection)
+          {
+            updateSearchIndex: coll_name,
+            :$db => db_name,
+            definition: index,
+          }.tap do |sel|
+            sel[:id] = index_id if index_id
+            sel[:name] = index_name if index_name
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongo/operation/update_search_index.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'mongo/operation/update_search_index/op_msg'
+
+module Mongo
+  module Operation
+    # A MongoDB updateSearchIndex command operation.
+    #
+    # @api private
+    class UpdateSearchIndex
+      include Specifiable
+      include OpMsgExecutable
+    end
+  end
+end

data/lib/mongo/operation.rb

@@ -22,6 +22,7 @@ require 'mongo/operation/shared/specifiable'
 require 'mongo/operation/shared/validatable'
 require 'mongo/operation/shared/object_id_generator'
 require 'mongo/operation/shared/op_msg_executable'
+require 'mongo/operation/shared/timed'
 
 require 'mongo/operation/op_msg_base'
 require 'mongo/operation/command'
@@ -51,6 +52,9 @@ require 'mongo/operation/update_user'
 require 'mongo/operation/remove_user'
 require 'mongo/operation/create_index'
 require 'mongo/operation/drop_index'
+require 'mongo/operation/create_search_indexes'
+require 'mongo/operation/drop_search_index'
+require 'mongo/operation/update_search_index'
 
 module Mongo
 

data/lib/mongo/protocol/message.rb

@@ -244,10 +244,7 @@ module Mongo
         # timeout option. For compatibility with whoever might call this
         # method with some other IO-like object, pass options only when they
         # are not empty.
-        read_options = {}
-        if timeout = options[:socket_timeout]
-          read_options[:timeout] = timeout
-        end
+        read_options = options.slice(:timeout, :socket_timeout)
 
         if read_options.empty?
           chunk = io.read(16)

data/lib/mongo/protocol/msg.rb

@@ -226,7 +226,7 @@ module Mongo
 
           db_name = @main_document[DATABASE_IDENTIFIER]
           cmd = merge_sections
-          enc_cmd = context.encrypter.encrypt(db_name, cmd)
+          enc_cmd = context.encrypt(db_name, cmd)
           if cmd.key?('$db') && !enc_cmd.key?('$db')
             enc_cmd['$db'] = cmd['$db']
           end
@@ -251,7 +251,7 @@ module Mongo
       def maybe_decrypt(context)
         if context.decrypt?
           cmd = merge_sections
-          enc_cmd = context.encrypter.decrypt(cmd)
+          enc_cmd = context.decrypt(cmd)
           Msg.new(@flags, @options, enc_cmd)
         else
           self

data/lib/mongo/retryable/base_worker.rb

@@ -49,7 +49,8 @@ module Mongo
 
       private
 
-      # Indicate which exception classes that are generally retryable. 
+      # Indicate which exception classes that are generally retryable
+      # when using modern retries mechanism.
       #
       # @return [ Array<Mongo:Error> ] Array of exception classes that are
       #   considered retryable.
@@ -58,18 +59,42 @@ module Mongo
           Error::ConnectionPerished,
           Error::ServerNotUsable,
           Error::SocketError,
-          Error::SocketTimeoutError
+          Error::SocketTimeoutError,
         ].freeze
       end
 
+      # Indicate which exception classes that are generally retryable
+      # when using legacy retries mechanism.
+      #
+      # @return [ Array<Mongo:Error> ] Array of exception classes that are
+      #   considered retryable.
+      def legacy_retryable_exceptions
+        [
+          Error::ConnectionPerished,
+          Error::ServerNotUsable,
+          Error::SocketError,
+          Error::SocketTimeoutError,
+          Error::PoolClearedError,
+          Error::PoolPausedError,
+        ].freeze
+      end
+
+
       # Tests to see if the given exception instance is of a type that can
-      # be retried.
+      # be retried with modern retry mechanism.
       #
       # @return [ true | false ] true if the exception is retryable.
       def is_retryable_exception?(e)
         retryable_exceptions.any? { |klass| klass === e }
       end
 
+      # Tests to see if the given exception instance is of a type that can
+      # be retried with legacy retry mechanism.
+      #
+      # @return [ true | false ] true if the exception is retryable.
+      def is_legacy_retryable_exception?(e)
+        legacy_retryable_exceptions.any? { |klass| klass === e }
+      end
       # Logs the given deprecation warning the first time it is called for a
       # given key; after that, it does nothing when given the same key.
       def deprecation_warning(key, warning)