mongo 2.15.0 → 2.16.0.alpha1

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