mongo 2.19.1 → 2.21.0

data/lib/mongo/retryable/read_worker.rb

@@ -60,19 +60,21 @@ module Mongo
       # @param [ Mongo::ServerSelector::Selectable ] server_selector Server
       #   selector for the operation.
       # @param [ CollectionView ] view The +CollectionView+ defining the query.
+      # @param [ Operation::Context | nil ] context the operation context to use
+      #   with the cursor.
       # @param [ Proc ] block The block to execute.
       #
       # @return [ Cursor ] The cursor for the result set.
-      def read_with_retry_cursor(session, server_selector, view, &block)
-        read_with_retry(session, server_selector) do |server|
+      def read_with_retry_cursor(session, server_selector, view, context: nil, &block)
+        read_with_retry(session, server_selector, context) do |server|
           result = yield server
 
           # RUBY-2367: This will be updated to allow the query cache to
           # cache cursors with multi-batch results.
           if QueryCache.enabled? && !view.collection.system_collection?
-            CachingCursor.new(view, result, server, session: session)
+            CachingCursor.new(view, result, server, session: session, context: context)
           else
-            Cursor.new(view, result, server, session: session)
+            Cursor.new(view, result, server, session: session, context: context)
           end
         end
       end
@@ -107,16 +109,18 @@ module Mongo
       #   is being run on.
       # @param [ Mongo::ServerSelector::Selectable | nil ] server_selector
       #   Server selector for the operation.
+      # @param [ Mongo::Operation::Context | nil ] context Context for the
+      #   read operation.
       # @param [ Proc ] block The block to execute.
       #
       # @return [ Result ] The result of the operation.
-      def read_with_retry(session = nil, server_selector = nil, &block)
+      def read_with_retry(session = nil, server_selector = nil, context = nil, &block)
         if session.nil? && server_selector.nil?
           deprecated_legacy_read_with_retry(&block)
         elsif session&.retry_reads?
-          modern_read_with_retry(session, server_selector, &block)
+          modern_read_with_retry(session, server_selector, context, &block)
         elsif client.max_read_retries > 0
-          legacy_read_with_retry(session, server_selector, &block)
+          legacy_read_with_retry(session, server_selector, context, &block)
         else
           read_without_retry(session, server_selector, &block)
         end
@@ -186,18 +190,26 @@ module Mongo
       #   being run on.
       # @param [ Mongo::ServerSelector::Selectable ] server_selector Server
       #   selector for the operation.
+      # @param [ Mongo::Operation::Context ] context Context for the
+      #   read operation.
       # @param [ Proc ] block The block to execute.
       #
       # @return [ Result ] The result of the operation.
-      def modern_read_with_retry(session, server_selector, &block)
-        yield select_server(cluster, server_selector, session)
-      rescue *retryable_exceptions, Error::OperationFailure, Auth::Unauthorized, Error::PoolError => e
+      def modern_read_with_retry(session, server_selector, context, &block)
+        server = select_server(
+          cluster,
+          server_selector,
+          session,
+          timeout: context&.remaining_timeout_sec
+        )
+        yield server
+      rescue *retryable_exceptions, Error::OperationFailure::Family, Auth::Unauthorized, Error::PoolError => e
         e.add_notes('modern retry', 'attempt 1')
         raise e if session.in_transaction?
         raise e if !is_retryable_exception?(e) && !e.write_retryable?
-        retry_read(e, session, server_selector, &block)
+        retry_read(e, session, server_selector, context: context, failed_server: server, &block)
       end
-  
+
       # Attempts to do a "legacy" read with retry. The operation will be
       # attempted multiple times, up to the client's `max_read_retries`
       # setting.
@@ -206,23 +218,26 @@ module Mongo
       #   being run on.
       # @param [ Mongo::ServerSelector::Selectable ] server_selector Server
       #   selector for the operation.
+      # @param [ Mongo::Operation::Context | nil ] context Context for the
+      #   read operation.
       # @param [ Proc ] block The block to execute.
       #
       # @return [ Result ] The result of the operation.
-      def legacy_read_with_retry(session, server_selector, &block)
+      def legacy_read_with_retry(session, server_selector, context = nil, &block)
+        context&.check_timeout!
         attempt = attempt ? attempt + 1 : 1
         yield select_server(cluster, server_selector, session)
-      rescue *retryable_exceptions, Error::OperationFailure, Error::PoolError => e
+      rescue *legacy_retryable_exceptions, Error::OperationFailure::Family => e
         e.add_notes('legacy retry', "attempt #{attempt}")
-        
-        if is_retryable_exception?(e)
+
+        if is_legacy_retryable_exception?(e)
           raise e if attempt > client.max_read_retries || session&.in_transaction?
         elsif e.retryable? && !session&.in_transaction?
           raise e if attempt > client.max_read_retries
         else
           raise e
         end
-        
+
         log_retry(e, message: 'Legacy read retry')
         sleep(client.read_retry_interval) unless is_retryable_exception?(e)
         retry
@@ -243,7 +258,7 @@ module Mongo
 
         begin
           yield server
-        rescue *retryable_exceptions, Error::PoolError, Error::OperationFailure => e
+        rescue *retryable_exceptions, Error::PoolError, Error::OperationFailure::Family => e
           e.add_note('retries disabled')
           raise e
         end
@@ -257,40 +272,67 @@ module Mongo
       #   being run on.
       # @param [ Mongo::ServerSelector::Selectable ] server_selector Server
       #   selector for the operation.
+      # @param [ Mongo::Operation::Context | nil ] :context Context for the
+      #   read operation.
+      # @param [ Mongo::Server | nil ] :failed_server The server on which the original
+      #   operation failed.
       # @param [ Proc ] block The block to execute.
-      # 
+      #
       # @return [ Result ] The result of the operation.
-      def retry_read(original_error, session, server_selector, &block)
-        begin
-          server = select_server(cluster, server_selector, session)
-        rescue Error, Error::AuthError => e
-          original_error.add_note("later retry failed: #{e.class}: #{e}")
-          raise original_error
-        end
-  
+      def retry_read(original_error, session, server_selector, context: nil, failed_server: nil, &block)
+        server = select_server_for_retry(
+          original_error, session, server_selector, context, failed_server
+        )
+
         log_retry(original_error, message: 'Read retry')
-  
+
         begin
+          context&.check_timeout!
+          attempt = attempt ? attempt + 1 : 2
           yield server, true
+        rescue Error::TimeoutError
+          raise
         rescue *retryable_exceptions => e
-          e.add_notes('modern retry', 'attempt 2')
-          raise e
-        rescue Error::OperationFailure, Error::PoolError => e
+          e.add_notes('modern retry', "attempt #{attempt}")
+          if context&.csot?
+            failed_server = server
+            retry
+          else
+            raise e
+          end
+        rescue Error::OperationFailure::Family, Error::PoolError => e
           e.add_note('modern retry')
-          unless e.write_retryable?
+          if e.write_retryable?
+            e.add_note("attempt #{attempt}")
+            if context&.csot?
+              failed_server = server
+              retry
+            else
+              raise e
+            end
+          else
             original_error.add_note("later retry failed: #{e.class}: #{e}")
             raise original_error
           end
-          e.add_note("attempt 2")
-          raise e
         rescue Error, Error::AuthError => e
           e.add_note('modern retry')
           original_error.add_note("later retry failed: #{e.class}: #{e}")
           raise original_error
         end
       end
-  
-    end
 
+      def select_server_for_retry(original_error, session, server_selector, context, failed_server)
+        select_server(
+          cluster,
+          server_selector,
+          session,
+          failed_server,
+          timeout: context&.remaining_timeout_sec
+        )
+      rescue Error, Error::AuthError => e
+        original_error.add_note("later retry failed: #{e.class}: #{e}")
+        raise original_error
+      end
+    end
   end
 end

data/lib/mongo/retryable/write_worker.rb

@@ -74,7 +74,11 @@ module Mongo
         # If we are here, session is not nil. A session being nil would have
         # failed retry_write_allowed? check.
 
-        server = select_server(cluster, ServerSelector.primary, session)
+        server = select_server(
+          cluster, ServerSelector.primary,
+          session,
+          timeout: context.remaining_timeout_sec
+        )
 
         unless ending_transaction || server.retry_writes?
           return legacy_write_with_retry(server, context: context, &block)
@@ -103,13 +107,14 @@ module Mongo
       def nro_write_with_retry(write_concern, context:, &block)
         session = context.session
         server = select_server(cluster, ServerSelector.primary, session)
-        
-        if session&.client.options[:retry_writes]
+        options = session&.client&.options || {}
+
+        if options[:retry_writes]
           begin
             server.with_connection(connection_global_id: context.connection_global_id) do |connection|
               yield connection, nil, context
             end
-          rescue *retryable_exceptions, Error::PoolError, Error::OperationFailure => e
+          rescue *retryable_exceptions, Error::PoolError, Error::OperationFailure::Family => e
             e.add_note('retries disabled')
             raise e
           end
@@ -169,6 +174,7 @@ module Mongo
       # @api private
       def legacy_write_with_retry(server = nil, context:)
         session = context.session
+        context.check_timeout!
 
         # This is the pre-session retry logic, and is not subject to
         # current retryable write specifications.
@@ -176,12 +182,20 @@ module Mongo
         attempt = 0
         begin
           attempt += 1
-          server ||= select_server(cluster, ServerSelector.primary, session)
-          server.with_connection(connection_global_id: context.connection_global_id) do |connection|
+          server ||= select_server(
+            cluster,
+            ServerSelector.primary,
+            session,
+            timeout: context.remaining_timeout_sec
+          )
+          server.with_connection(
+            connection_global_id: context.connection_global_id,
+            context: context
+          ) do |connection|
             # Legacy retries do not use txn_num
             yield connection, nil, context.dup
           end
-        rescue Error::OperationFailure => e
+        rescue Error::OperationFailure::Family => e
           e.add_note('legacy retry')
           e.add_note("attempt #{attempt}")
           server = nil
@@ -218,8 +232,11 @@ module Mongo
       def modern_write_with_retry(session, server, context, &block)
         txn_num = nil
         connection_succeeded = false
-        
-        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|
           connection_succeeded = true
 
           session.materialize_if_needed
@@ -229,10 +246,10 @@ module Mongo
           # it later for the retry as well.
           yield connection, txn_num, context.dup
         end
-      rescue *retryable_exceptions, Error::PoolError, Auth::Unauthorized, Error::OperationFailure => e
+      rescue *retryable_exceptions, Error::PoolError, Auth::Unauthorized, Error::OperationFailure::Family => e
         e.add_notes('modern retry', 'attempt 1')
 
-        if e.is_a?(Error::OperationFailure)
+        if e.is_a?(Error::OperationFailure::Family)
           ensure_retryable!(e)
         else
           ensure_labeled_retryable!(e, connection_succeeded, session)
@@ -240,7 +257,7 @@ module Mongo
 
         # Context#with creates a new context, which is not necessary here
         # but the API is less prone to misuse this way.
-        retry_write(e, txn_num, context: context.with(is_retry: true), &block)
+        retry_write(e, txn_num, context: context.with(is_retry: true), failed_server: server, &block)
       end
 
       # Called after a failed write, this will retry the write no more than
@@ -250,9 +267,13 @@ module Mongo
       #   retry.
       # @param [ Number ] txn_num The transaction number.
       # @param [ Operation::Context ] context The context for the operation.
+      # @param [ Mongo::Server ] failed_server The server on which the original
+      #   operation failed.
       #
       # @return [ Result ] The result of the operation.
-      def retry_write(original_error, txn_num, context:, &block)
+      def retry_write(original_error, txn_num, context:, failed_server: nil, &block)
+        context&.check_timeout!
+
         session = context.session
 
         # We do not request a scan of the cluster here, because error handling
@@ -260,8 +281,14 @@ module Mongo
         # server description and/or topology as necessary (specifically,
         # a socket error or a not master error should have marked the respective
         # server unknown). Here we just need to wait for server selection.
-        server = select_server(cluster, ServerSelector.primary, session)
-        
+        server = select_server(
+          cluster,
+          ServerSelector.primary,
+          session,
+          failed_server,
+          timeout: context.remaining_timeout_sec
+        )
+
         unless server.retry_writes?
           # Do not need to add "modern retry" here, it should already be on
           # the first exception.
@@ -275,15 +302,22 @@ module Mongo
           # special marker class to bypass the ordinarily applicable rescues.
           raise Error::RaiseOriginalError
         end
-        
+
+        attempt = attempt ? attempt + 1 : 2
         log_retry(original_error, message: 'Write retry')
         server.with_connection(connection_global_id: context.connection_global_id) do |connection|
           yield(connection, txn_num, context)
         end
       rescue *retryable_exceptions, Error::PoolError => e
-        fail_on_retryable!(e, original_error)
-      rescue Error::OperationFailure => e
-        fail_on_operation_failure!(e, original_error)
+        maybe_fail_on_retryable(e, original_error, context, attempt)
+        failed_server = server
+        retry
+      rescue Error::OperationFailure::Family => e
+        maybe_fail_on_operation_failure(e, original_error, context, attempt)
+        failed_server = server
+        retry
+      rescue Mongo::Error::TimeoutError
+        raise
       rescue Error, Error::AuthError => e
         fail_on_other_error!(e, original_error)
       rescue Error::RaiseOriginalError
@@ -329,10 +363,10 @@ module Mongo
 
       # Raise either e, or original_error, depending on whether e is
       # write_retryable.
-      def fail_on_retryable!(e, original_error)
+      def maybe_fail_on_retryable(e, original_error, context, attempt)
         if e.write_retryable?
-          e.add_notes('modern retry', 'attempt 2')
-          raise e
+          e.add_notes('modern retry', "attempt #{attempt}")
+          raise e unless context&.deadline
         else
           original_error.add_note("later retry failed: #{e.class}: #{e}")
           raise original_error
@@ -341,11 +375,11 @@ module Mongo
 
       # Raise either e, or original_error, depending on whether e is
       # appropriately labeled.
-      def fail_on_operation_failure!(e, original_error)
+      def maybe_fail_on_operation_failure(e, original_error, context, attempt)
         e.add_note('modern retry')
         if e.label?('RetryableWriteError') && !e.label?('NoWritesPerformed')
-          e.add_note('attempt 2')
-          raise e
+          e.add_note("attempt #{attempt}")
+          raise e unless context&.deadline
         else
           original_error.add_note("later retry failed: #{e.class}: #{e}")
           raise original_error

data/lib/mongo/retryable.rb

@@ -46,8 +46,14 @@ module Mongo
     # @api private
     #
     # @return [ Mongo::Server ] A server matching the server preference.
-    def select_server(cluster, server_selector, session)
-      server_selector.select_server(cluster, nil, session)
+    def select_server(cluster, server_selector, session, failed_server = nil, timeout: nil)
+      server_selector.select_server(
+        cluster,
+        nil,
+        session,
+        deprioritized: [failed_server].compact,
+        timeout: timeout
+      )
     end
 
     # Returns the read worker for handling retryable reads.

data/lib/mongo/search_index/view.rb

@@ -0,0 +1,232 @@
+# frozen_string_literal: true
+
+module Mongo
+  module SearchIndex
+    # A class representing a view of search indexes.
+    class View
+      include Enumerable
+      include Retryable
+      include Collection::Helpers
+
+      # @return [ Mongo::Collection ] the collection this view belongs to
+      attr_reader :collection
+
+      # @return [ nil | String ] the index id to query
+      attr_reader :requested_index_id
+
+      # @return [ nil | String ] the index name to query
+      attr_reader :requested_index_name
+
+      # @return [ Hash ] the options hash to use for the aggregate command
+      #   when querying the available indexes.
+      attr_reader :aggregate_options
+
+      # Create the new search index view.
+      #
+      # @param [ Collection ] collection The collection.
+      # @param [ Hash ] options The options that configure the behavior of the view.
+      #
+      # @option options [ String ] :id The specific index id to query (optional)
+      # @option options [ String ] :name The name of the specific index to query (optional)
+      # @option options [ Hash ] :aggregate The options hash to send to the
+      #   aggregate command when querying the available indexes.
+      def initialize(collection, options = {})
+        @collection = collection
+        @requested_index_id = options[:id]
+        @requested_index_name = options[:name]
+        @aggregate_options = options[:aggregate] || {}
+
+        return if @aggregate_options.is_a?(Hash)
+
+        raise ArgumentError, "The :aggregate option must be a Hash (got a #{@aggregate_options.class})"
+      end
+
+      # Create a single search index with the given definition. If the name is
+      # provided, the new index will be given that name.
+      #
+      # @param [ Hash ] definition The definition of the search index.
+      # @param [ nil | String ] name The name to give the new search index.
+      #
+      # @return [ String ] the name of the new search index.
+      def create_one(definition, name: nil)
+        create_many([ { name: name, definition: definition } ]).first
+      end
+
+      # Create multiple search indexes with a single command.
+      #
+      # @param [ Array<Hash> ] indexes The description of the indexes to
+      #   create. Each element of the list must be a hash with a definition
+      #   key, and an optional name key.
+      #
+      # @return [ Array<String> ] the names of the new search indexes.
+      def create_many(indexes)
+        spec = spec_with(indexes: indexes.map { |v| validate_search_index!(v) })
+        result = Operation::CreateSearchIndexes.new(spec).execute(next_primary, context: execution_context)
+        result.first['indexesCreated'].map { |idx| idx['name'] }
+      end
+
+      # Drop the search index with the given id, or name. One or the other must
+      # be specified, but not both.
+      #
+      # @param [ String ] id the id of the index to drop
+      # @param [ String ] name the name of the index to drop
+      #
+      # @return [ Mongo::Operation::Result | false ] the result of the
+      #    operation, or false if the given index does not exist.
+      def drop_one(id: nil, name: nil)
+        validate_id_or_name!(id, name)
+
+        spec = spec_with(index_id: id, index_name: name)
+        op = Operation::DropSearchIndex.new(spec)
+
+        # per the spec:
+        # Drivers MUST suppress NamespaceNotFound errors for the
+        # ``dropSearchIndex`` helper.  Drop operations should be idempotent.
+        do_drop(op, nil, execution_context)
+      end
+
+      # Iterate over the search indexes.
+      #
+      # @param [ Proc ] block if given, each search index will be yieleded to
+      #    the block.
+      #
+      # @return [ self | Enumerator ] if a block is given, self is returned.
+      #    Otherwise, an enumerator will be returned.
+      def each(&block)
+        @result ||= begin
+          spec = {}.tap do |s|
+            s[:id] = requested_index_id if requested_index_id
+            s[:name] = requested_index_name if requested_index_name
+          end
+
+          collection.aggregate(
+            [ { '$listSearchIndexes' => spec } ],
+            aggregate_options
+          )
+        end
+
+        return @result.to_enum unless block
+
+        @result.each(&block)
+        self
+      end
+
+      # Update the search index with the given id or name. One or the other
+      # must be provided, but not both.
+      #
+      # @param [ Hash ] definition the definition to replace the given search
+      #    index with.
+      # @param [ nil | String ] id the id of the search index to update
+      # @param [ nil | String ] name the name of the search index to update
+      #
+      # @return [ Mongo::Operation::Result ] the result of the operation
+      def update_one(definition, id: nil, name: nil)
+        validate_id_or_name!(id, name)
+
+        spec = spec_with(index_id: id, index_name: name, index: definition)
+        Operation::UpdateSearchIndex.new(spec).execute(next_primary, context: execution_context)
+      end
+
+      # The following methods are to make the view act more like an array,
+      # without having to explicitly make it an array...
+
+      # Queries whether the search index enumerable is empty.
+      #
+      # @return [ true | false ] whether the enumerable is empty or not.
+      def empty?
+        count.zero?
+      end
+
+      private
+
+      # A helper method for building the specification document with certain
+      # values pre-populated.
+      #
+      # @param [ Hash ] extras the values to put into the specification
+      #
+      # @return [ Hash ] the specification document
+      def spec_with(extras)
+        {
+          coll_name: collection.name,
+          db_name: collection.database.name,
+        }.merge(extras)
+      end
+
+      # A helper method for retrieving the primary server from the cluster.
+      #
+      # @return [ Mongo::Server ] the server to use
+      def next_primary(ping = nil, session = nil)
+        collection.cluster.next_primary(ping, session)
+      end
+
+      # A helper method for constructing a new operation context for executing
+      # an operation.
+      #
+      # @return [ Mongo::Operation::Context ] the operation context
+      def execution_context
+        Operation::Context.new(client: collection.client)
+      end
+
+      # Validates the given id and name, ensuring that exactly one of them
+      # is non-nil.
+      #
+      # @param [ nil | String ] id the id to validate
+      # @param [ nil | String ] name the name to validate
+      #
+      # @raise [ ArgumentError ] if neither or both arguments are nil
+      def validate_id_or_name!(id, name)
+        return unless (id.nil? && name.nil?) || (!id.nil? && !name.nil?)
+
+        raise ArgumentError, 'exactly one of id or name must be specified'
+      end
+
+      # Validates the given search index document, ensuring that it has no
+      # extra keys, and that the name and definition are valid.
+      #
+      # @param [ Hash ] doc the document to validate
+      #
+      # @raise [ ArgumentError ] if the document is invalid.
+      def validate_search_index!(doc)
+        validate_search_index_keys!(doc.keys)
+        validate_search_index_name!(doc[:name] || doc['name'])
+        validate_search_index_definition!(doc[:definition] || doc['definition'])
+        doc
+      end
+
+      # Validates the keys of a search index document, ensuring that
+      # they are all valid.
+      #
+      # @param [ Array<String | Hash> ] keys the keys of a search index document
+      #
+      # @raise [ ArgumentError ] if the list contains any invalid keys
+      def validate_search_index_keys!(keys)
+        extras = keys - [ 'name', 'definition', :name, :definition ]
+
+        raise ArgumentError, "invalid keys in search index creation: #{extras.inspect}" if extras.any?
+      end
+
+      # Validates the name of a search index, ensuring that it is either a
+      # String or nil.
+      #
+      # @param [ nil | String ] name the name of a search index
+      #
+      # @raise [ ArgumentError ] if the name is not valid
+      def validate_search_index_name!(name)
+        return if name.nil? || name.is_a?(String)
+
+        raise ArgumentError, "search index name must be nil or a string (got #{name.inspect})"
+      end
+
+      # Validates the definition of a search index.
+      #
+      # @param [ Hash ] definition the definition of a search index
+      #
+      # @raise [ ArgumentError ] if the definition is not valid
+      def validate_search_index_definition!(definition)
+        return if definition.is_a?(Hash)
+
+        raise ArgumentError, "search index definition must be a Hash (got #{definition.inspect})"
+      end
+    end
+  end
+end