mongo 2.15.0 → 2.16.1

data/lib/mongo/collection/view.rb

@@ -141,6 +141,8 @@ module Mongo
       # @option options [ Hash ] :read The read preference to use for the
       #   query. If none is provided, the collection's default read preference
       #   is used.
+      # @option options [ Hash ] :read_concern The read concern to use for
+      #   the query.
       # @option options [ true | false ] :show_disk_loc Return disk location
       #   info as a field in each doc.
       # @option options [ Integer ] :skip The number of documents to skip.
@@ -153,7 +155,19 @@ module Mongo
       def initialize(collection, filter = {}, options = {})
         validate_doc!(filter)
         @collection = collection
-        parse_parameters!(BSON::Document.new(filter), BSON::Document.new(options))
+
+        filter = BSON::Document.new(filter)
+        options = BSON::Document.new(options)
+
+        # This is when users pass $query in filter and other modifiers
+        # alongside?
+        query = filter.delete(:$query)
+        # This makes modifiers contain the filter if filter wasn't
+        # given via $query but as top-level keys, presumably
+        # downstream code ignores non-modifier keys in the modifiers?
+        modifiers = filter.merge(options.delete(:modifiers) || {})
+        @filter = (query || filter).freeze
+        @options = Operation::Find::Builder::Modifiers.map_driver_options(modifiers).merge!(options).freeze
       end
 
       # Get a human-readable string representation of +View+.
@@ -189,30 +203,10 @@ module Mongo
         @filter = other.filter.dup
       end
 
-      def parse_parameters!(filter, options)
-        query = filter.delete(QUERY)
-        modifiers = (filter || {}).merge(options.delete(MODIFIERS) || {})
-        @filter = (query || filter).freeze
-        @options = Builder::Modifiers.map_driver_options(modifiers).merge!(options).freeze
-      end
-
       def new(options)
         View.new(collection, filter, options)
       end
 
-      def apply_collation!(doc, server, opts = {})
-        if coll = doc[:collation] || opts[:collation] || opts['collation'] || collation
-          validate_collation!(server, coll)
-          doc[:collation] = coll
-        end
-      end
-
-      def validate_collation!(server, coll)
-        if coll && !server.with_connection { |connection| connection.features }.collation_enabled?
-          raise Error::UnsupportedCollation.new
-        end
-      end
-
       def view; self; end
 
       def with_session(opts = {}, &block)

data/lib/mongo/collection.rb

@@ -251,7 +251,7 @@ module Mongo
       # TODO put the list of read options in a class-level constant when
       # we figure out what the full set of them is.
       options = Hash[self.options.reject do |key, value|
-        %w(read read_preference).include?(key.to_s)
+        %w(read read_preference read_concern).include?(key.to_s)
       end]
       options.update(Utils.slice_hash(opts, *TIME_SERIES_OPTIONS.keys))
       # Converting Ruby spelled time series options to server style.
@@ -269,17 +269,17 @@ module Mongo
         else
           self.write_concern
         end
-        server = next_primary(nil, session)
-        if (options[:collation] || options[Operation::COLLATION]) && !server.with_connection { |connection| connection.features }.collation_enabled?
-          raise Error::UnsupportedCollation
-        end
 
-        Operation::Create.new({
-                                selector: operation,
-                                db_name: database.name,
-                                write_concern: write_concern,
-                                session: session,
-                                }).execute(server, context: Operation::Context.new(client: client, session: session))
+        context = Operation::Context.new(client: client, session: session)
+        Operation::Create.new(
+          selector: operation,
+          db_name: database.name,
+          write_concern: write_concern,
+          session: session,
+          # Note that these are collection options, collation isn't
+          # taken from options passed to the create method.
+          collation: options[:collation] || options['collation'],
+        ).execute(next_primary(nil, session), context: context)
       end
     end
 
@@ -353,8 +353,8 @@ module Mongo
     # @option options [ true, false ] :no_cursor_timeout The server normally times out idle
     #   cursors after an inactivity period (10 minutes) to prevent excess memory use.
     #   Set this option to prevent that.
-    # @option options [ true, false ] :oplog_replay Internal replication use only - driver
-    #   should not set.
+    # @option options [ true, false ] :oplog_replay For internal replication
+    #   use only, applications should not set this option.
     # @option options [ Hash ] :projection The fields to include or exclude from each doc
     #   in the result set.
     # @option options [ Session ] :session The session to use.

data/lib/mongo/cursor/kill_spec.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+# Copyright (C) 2021 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 Cursor
+
+    # This class contains the operation specification for KillCursors.
+    #
+    # Its purpose is to ensure we don't misspell attribute names accidentally.
+    #
+    # @api private
+    class KillSpec
+
+      def initialize(cursor_id:, coll_name:, db_name:, service_id:)
+        @cursor_id = cursor_id
+        @coll_name = coll_name
+        @db_name = db_name
+        @service_id = service_id
+      end
+
+      attr_reader :cursor_id, :coll_name, :db_name, :service_id
+    end
+  end
+end

data/lib/mongo/cursor.rb

@@ -15,8 +15,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require 'mongo/cursor/builder'
-
 module Mongo
 
   # Client-side representation of an iterator over a query result set on
@@ -69,6 +67,10 @@ module Mongo
     #
     # @since 2.0.0
     def initialize(view, result, server, options = {})
+      unless result.is_a?(Operation::Result)
+        raise ArgumentError, "Second argument must be a Mongo::Operation::Result: #{result.inspect}"
+      end
+
       @view = view
       @server = server
       @initial_result = result
@@ -82,9 +84,8 @@ module Mongo
       @session = @options[:session]
       unless closed?
         register
-        ObjectSpace.define_finalizer(self, self.class.finalize(@cursor_id,
+        ObjectSpace.define_finalizer(self, self.class.finalize(kill_spec,
           cluster,
-          kill_cursors_op_spec,
           server,
           @session))
       end
@@ -93,23 +94,25 @@ module Mongo
     # @api private
     attr_reader :server
 
+    # @api private
+    attr_reader :initial_result
+
     # Finalize the cursor for garbage collection. Schedules this cursor to be included
     # in a killCursors operation executed by the Cluster's CursorReaper.
     #
-    # @example Finalize the cursor.
-    #   Cursor.finalize(id, cluster, op, server)
-    #
-    # @param [ Integer ] cursor_id The cursor's id.
+    # @param [ Cursor::KillSpec ] kill_spec The KillCursor operation specification.
     # @param [ Mongo::Cluster ] cluster The cluster associated with this cursor and its server.
-    # @param [ Hash ] op_spec The killCursors operation specification.
     # @param [ Mongo::Server ] server The server to send the killCursors operation to.
     #
     # @return [ Proc ] The Finalizer.
     #
-    # @since 2.3.0
-    def self.finalize(cursor_id, cluster, op_spec, server, session)
+    # @api private
+    def self.finalize(kill_spec, cluster, server, session)
+      unless KillSpec === kill_spec
+        raise ArgumentError, "First argument must be a KillSpec: #{kill_spec.inspect}"
+      end
       proc do
-        cluster.schedule_kill_cursor(cursor_id, op_spec, server)
+        cluster.schedule_kill_cursor(kill_spec, server)
         session.end_session if session && session.implicit?
       end
     end
@@ -212,10 +215,12 @@ module Mongo
         unless closed?
           if exhausted?
             close
+            @fully_iterated = true
             raise StopIteration
           end
           @documents = get_more
         else
+          @fully_iterated = true
           raise StopIteration
         end
       else
@@ -232,6 +237,9 @@ module Mongo
       # over the last document, or if the batch is empty
       if @documents.size <= 1
         cache_batch_resume_token
+        if closed?
+          @fully_iterated = true
+        end
       end
 
       return @documents.shift
@@ -274,7 +282,13 @@ module Mongo
 
       unregister
       read_with_one_retry do
-        kill_cursors_operation.execute(@server, context: Operation::Context.new(client: client, session: @session))
+        spec = {
+          coll_name: collection_name,
+          db_name: database.name,
+          cursor_ids: [id],
+        }
+        op = Operation::KillCursors.new(spec)
+        execute_operation(op)
       end
 
       nil
@@ -349,7 +363,22 @@ module Mongo
       # doing so may result in silent data loss, the driver no longer retries
       # getMore operations in any circumstance.
       # https://github.com/mongodb/specifications/blob/master/source/retryable-reads/retryable-reads.rst#qa
-      process(get_more_operation.execute(@server, context: Operation::Context.new(client: client, session: @session)))
+      process(execute_operation(get_more_operation))
+    end
+
+    # @api private
+    def kill_spec
+      KillSpec.new(
+        cursor_id: id,
+        coll_name: collection_name,
+        db_name: database.name,
+        service_id: initial_result.connection_description.service_id,
+      )
+    end
+
+    # @api private
+    def fully_iterated?
+      !!@fully_iterated
     end
 
     private
@@ -369,11 +398,24 @@ module Mongo
     end
 
     def get_more_operation
-      if @server.with_connection { |connection| connection.features }.find_command_enabled?
-        spec = Builder::GetMoreCommand.new(self, @session).specification
-      else
-        spec = Builder::OpGetMore.new(self).specification
-      end
+      spec = {
+        session: @session,
+        db_name: database.name,
+        coll_name: collection_name,
+        cursor_id: id,
+        # 3.2+ servers use batch_size, 3.0- servers use to_return.
+        # TODO should to_return be calculated in the operation layer?
+        batch_size: batch_size,
+        to_return: to_return,
+        max_time_ms: if view.respond_to?(:max_await_time_ms) &&
+          view.max_await_time_ms &&
+          view.options[:await_data]
+        then
+          view.max_await_time_ms
+        else
+          nil
+        end,
+      }
       Operation::GetMore.new(spec)
     end
 
@@ -381,18 +423,6 @@ module Mongo
       @session.end_session if @session && @session.implicit?
     end
 
-    def kill_cursors_operation
-      Operation::KillCursors.new(kill_cursors_op_spec)
-    end
-
-    def kill_cursors_op_spec
-      if @server.with_connection { |connection| connection.features }.find_command_enabled?
-        Builder::KillCursorsCommand.new(self).specification
-      else
-        Builder::OpKillCursors.new(self).specification
-      end
-    end
-
     def limited?
       limit ? limit > 0 : false
     end
@@ -433,5 +463,16 @@ module Mongo
     def unregister
       cluster.unregister_cursor(@cursor_id)
     end
+
+    def execute_operation(op)
+      context = Operation::Context.new(
+        client: client,
+        session: @session,
+        service_id: initial_result.connection_description.service_id,
+      )
+      op.execute(@server, context: context)
+    end
   end
 end
+
+require 'mongo/cursor/kill_spec'

data/lib/mongo/database/view.rb

@@ -68,7 +68,7 @@ module Mongo
           send_initial_query(server, session, options.merge(name_only: true))
         end
         cursor.map do |info|
-          if cursor.server.with_connection { |connection| connection.features }.list_collections_enabled?
+          if cursor.initial_result.connection_description.features.list_collections_enabled?
             info['name']
           else
             (info['name'] &&

data/lib/mongo/error/bad_load_balancer_target.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+# Copyright (C) 2021 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 Error
+
+    # Raised when the driver is in load-balancing mode but a connection
+    # is established to something other than a mongos.
+    class BadLoadBalancerTarget < Error
+    end
+  end
+end

data/lib/mongo/error/missing_service_id.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+# Copyright (C) 2021 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 Error
+
+    # Raised when the driver is in load-balancing mode via the URI option
+    # but a connection does not report a value in the serviceId field.
+    class MissingServiceId < Error
+    end
+  end
+end

data/lib/mongo/error/no_service_connection_available.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+# Copyright (C) 2021 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 Error
+
+    # Raised when the driver requires a connection to a particular service
+    # but no matching connections exist in the connection pool.
+    class NoServiceConnectionAvailable < Error
+      # @api private
+      def initialize(message, address:, service_id:)
+        super(message)
+
+        @address = address
+        @service_id = service_id
+      end
+
+      # @return [ Mongo::Address ] The address to which a connection was
+      #   requested.
+      attr_reader :address
+
+      # @return [ nil | Object ] The service id.
+      attr_reader :service_id
+
+      # @api private
+      def self.generate(address:, service_id:)
+        new(
+          "The connection pool for #{address} does not have a connection for service #{service_id}",
+          address: address,
+          service_id: service_id,
+        )
+      end
+    end
+  end
+end

data/lib/mongo/error/notable.rb

@@ -63,6 +63,13 @@ module Mongo
       # @return [ Integer | nil ] Connection pool generation.
       attr_accessor :generation
 
+      # Returns service id for the connection on which the error occurred.
+      #
+      # @return [ Object | nil ] Service id.
+      #
+      # @api experimental
+      attr_accessor :service_id
+
       # @api public
       def to_s
         super + notes_tail

data/lib/mongo/error.rb

@@ -168,6 +168,7 @@ module Mongo
 end
 
 require 'mongo/error/auth_error'
+require 'mongo/error/bad_load_balancer_target'
 require 'mongo/error/sdam_error_detection'
 require 'mongo/error/parser'
 require 'mongo/error/write_retryable'
@@ -217,6 +218,7 @@ require 'mongo/error/mismatched_domain'
 require 'mongo/error/mongocryptd_spawn_error'
 require 'mongo/error/multi_index_drop'
 require 'mongo/error/need_primary_server'
+require 'mongo/error/no_service_connection_available'
 require 'mongo/error/no_server_available'
 require 'mongo/error/no_srv_records'
 require 'mongo/error/session_ended'
@@ -235,6 +237,7 @@ require 'mongo/error/missing_file_chunk'
 require 'mongo/error/missing_password'
 require 'mongo/error/missing_resume_token'
 require 'mongo/error/missing_scram_server_signature'
+require 'mongo/error/missing_service_id'
 require 'mongo/error/server_api_conflict'
 require 'mongo/error/server_api_not_supported'
 require 'mongo/error/unknown_payload_type'

data/lib/mongo/grid/fs_bucket.rb

@@ -508,8 +508,27 @@ module Mongo
 
       def ensure_indexes!
         if files_collection.find({}, limit: 1, projection: { _id: 1 }).first.nil?
-          chunks_collection.indexes.create_one(FSBucket::CHUNKS_INDEX, :unique => true)
-          files_collection.indexes.create_one(FSBucket::FILES_INDEX)
+          create_index_if_missing!(files_collection, FSBucket::FILES_INDEX)
+        end
+
+        if chunks_collection.find({}, limit: 1, projection: { _id: 1 }).first.nil?
+          create_index_if_missing!(chunks_collection, FSBucket::CHUNKS_INDEX, :unique => true)
+        end
+      end
+
+      def create_index_if_missing!(collection, index_spec, options = {})
+        indexes_view = collection.indexes
+        begin
+          if indexes_view.get(index_spec).nil?
+            indexes_view.create_one(index_spec, options)
+          end
+        rescue Mongo::Error::OperationFailure => e
+          # proceed with index creation if a NamespaceNotFound error is thrown
+          if e.code == 26
+            indexes_view.create_one(index_spec, options)
+          else
+            raise
+          end
         end
       end
     end

data/lib/mongo/id.rb

@@ -16,9 +16,10 @@
 # limitations under the License.
 
 module Mongo
-  # This module abstracts the functionality for generating sequential unique integer IDs for
-  # instances of the class. It defines the method #next_id on the class that includes it. The
-  # implementation ensures that the IDs will be unique even when called from multiple threads.
+  # This module abstracts the functionality for generating sequential
+  # unique integer IDs for instances of the class. It defines the method
+  # #next_id on the class that includes it. The implementation ensures that
+  # the IDs will be unique even when called from multiple threads.
   #
   # @example Include the Id module.
   #   class Foo
@@ -29,8 +30,9 @@ module Mongo
   #   foo.next_id # => 1
   #   foo.next_id # => 2
   #
-  # Classes which include Id should _not_ access `@@id` or `@@id_lock` directly; instead, they
-  # should call `#next_id` in `#initialize` and save the result in the instance being created.
+  # Classes which include Id should _not_ access `@@id` or `@@id_lock`
+  # directly; instead, they should call `#next_id` in `#initialize` and save
+  # the result in the instance being created.
   #
   # @example Save the ID in the instance of the including class.
   #   class Bar

data/lib/mongo/index/view.rb

@@ -129,7 +129,10 @@ module Mongo
       # @option options [ String | Integer ] :commit_quorum Specify how many
       #   data-bearing members of a replica set, including the primary, must
       #   complete the index builds successfully before the primary marks
-      #   the indexes as ready.
+      #   the indexes as ready. Potential values are:
+      #   - an integer from 0 to the number of members of the replica set
+      #   - "majority" indicating that a majority of data bearing nodes must vote
+      #   - "votingMembers" which means that all voting data bearing nodes must vote
       # @option options [ Session ] :session The session to use for the operation.
       #
       # @note Note that the options listed may be subset of those available.
@@ -177,7 +180,10 @@ module Mongo
       #   The following options are accepted:
       #   - commit_quorum: Specify how many data-bearing members of a replica set,
       #     including the primary, must complete the index builds successfully
-      #     before the primary marks the indexes as ready.
+      #     before the primary marks the indexes as ready. Potential values are:
+      #     - an integer from 0 to the number of members of the replica set
+      #     - "majority" indicating that a majority of data bearing nodes must vote
+      #     - "votingMembers" which means that all voting data bearing nodes must vote
       #   - session: The session to use.
       #
       # @return [ Result ] The result of the command.
@@ -193,17 +199,6 @@ module Mongo
         client.send(:with_session, @options.merge(options)) do |session|
           server = next_primary(nil, session)
 
-          # While server versions 3.4 and newer generally perform option
-          # validation, there was a bug on server versions 4.2.0 - 4.2.5 where
-          # the server would accept the commitQuorum option and use it internally
-          # (see SERVER-47193). As a result, the drivers specifications require
-          # drivers to perform validation and raise an error when the commitQuorum
-          # option is passed to servers that don't support it.
-          description = server.with_connection { |connection| connection.description }
-          if description.max_wire_version < 9 && options[:commit_quorum]
-            raise Error::UnsupportedOption.commit_quorum_error
-          end
-
           indexes = normalize_models(models, server)
           indexes.each do |index|
             if index[:bucketSize] || index['bucketSize']
@@ -216,10 +211,9 @@ module Mongo
             db_name: database.name,
             coll_name: collection.name,
             session: session,
-            commit_quorum: options[:commit_quorum]
-           }
-
-          spec[:write_concern] = write_concern if description.features.collation_enabled?
+            commit_quorum: options[:commit_quorum],
+            write_concern: write_concern,
+          }
 
           Operation::CreateIndex.new(spec).execute(server, context: Operation::Context.new(client: client, session: session))
         end
@@ -292,13 +286,13 @@ module Mongo
       def drop_by_name(name)
         client.send(:with_session, @options) do |session|
           spec = {
-                   db_name: database.name,
-                   coll_name: collection.name,
-                   index_name: name,
-                   session: session
-                 }
+            db_name: database.name,
+            coll_name: collection.name,
+            index_name: name,
+            session: session,
+            write_concern: write_concern,
+          }
           server = next_primary(nil, session)
-          spec[:write_concern] = write_concern if server.with_connection { |connection| connection.features }.collation_enabled?
           Operation::DropIndex.new(spec).execute(server, context: Operation::Context.new(client: client, session: session))
         end
       end
@@ -329,30 +323,17 @@ module Mongo
       end
 
       def normalize_models(models, server)
-        with_generated_names(models, server).map do |model|
-          Options::Mapper.transform(model, OPTIONS)
+        models.map do |model|
+          # Transform options first which gives us a mutable hash
+          Options::Mapper.transform(model, OPTIONS).tap do |model|
+            model[:name] ||= index_name(model.fetch(:key))
+          end
         end
       end
 
       def send_initial_query(server, session)
         initial_query_op(session).execute(server, context: Operation::Context.new(client: client, session: session))
       end
-
-      def with_generated_names(models, server)
-        models.dup.each do |model|
-          validate_collation!(model, server)
-          unless model[:name]
-            model[:name] = index_name(model[:key])
-          end
-        end
-      end
-
-      def validate_collation!(model, server)
-        if (model[:collation] || model[Operation::COLLATION]) &&
-            !server.with_connection { |connection| connection.features }.collation_enabled?
-          raise Error::UnsupportedCollation.new
-        end
-      end
     end
   end
 end