mongo 2.9.2 → 2.10.0.rc0

data/lib/mongo/collection/view.rb

@@ -46,7 +46,6 @@ module Mongo
       include Immutable
       include Iterable
       include Readable
-      include Retryable
       include Explainable
       include Writable
 
@@ -60,7 +59,12 @@ module Mongo
       def_delegators :collection,
                      :client,
                      :cluster,
-                     :database
+                     :database,
+                     :read_with_retry,
+                     :read_with_retry_cursor,
+                     :write_with_retry,
+                     :nro_write_with_retry,
+                     :write_concern_with_session
 
       # Delegate to the cluster for the next primary.
       def_delegators :cluster, :next_primary
@@ -163,7 +167,7 @@ module Mongo
       #
       # @since 2.0.0
       def write_concern
-        WriteConcern.get(options[:write] || options[:write_concern] || collection.write_concern)
+        WriteConcern.get(options[:write_concern] || options[:write] || collection.write_concern)
       end
 
       private

data/lib/mongo/collection/view/aggregation.rb

@@ -111,18 +111,18 @@ module Mongo
           server.standalone? || server.mongos? || server.primary? || secondary_ok?
         end
 
-        def out?
-          pipeline.any? { |op| op.key?('$out') || op.key?(:$out) }
+        def write?
+          pipeline.any? { |op| op.key?('$out') || op.key?(:$out) || op.key?('$merge') || op.key?(:$merge) }
         end
 
         def secondary_ok?
-          !out?
+          !write?
         end
 
         def send_initial_query(server, session)
           unless valid_server?(server)
             log_warn("Rerouting the Aggregation operation to the primary server - #{server.summary} is not suitable")
-            server = cluster.next_primary
+            server = cluster.next_primary(nil, session)
           end
           validate_collation!(server)
           initial_query_op(session).execute(server)

data/lib/mongo/collection/view/builder/aggregation.rb

@@ -78,22 +78,40 @@ module Mongo
             spec = {
                     selector: aggregation_command,
                     db_name: database.name,
-                    read: read,
+                    read: view.read_preference,
                     session: @options[:session]
                    }
-            write? ? spec.merge!(write_concern: write_concern) : spec
+            if write?
+              spec.update(write_concern: write_concern)
+            end
+            spec
           end
 
           private
 
           def write?
-            pipeline.any? { |operator| operator[:$out] || operator['$out'] }
+            pipeline.any? do |operator|
+              operator[:$out] || operator['$out'] ||
+              operator[:$merge] || operator['$merge']
+            end
           end
 
           def aggregation_command
-            command = BSON::Document.new(:aggregate => collection.name, :pipeline => pipeline)
+            command = BSON::Document.new
+            # aggregate must be the first key in the command document
+            if view.is_a?(Collection::View)
+              command[:aggregate] = collection.name
+            elsif view.is_a?(Database::View)
+              command[:aggregate] = 1
+            else
+              raise ArgumentError, "Unknown view class: #{view}"
+            end
+            command[:pipeline] = pipeline
+            if read_concern = view.read_concern
+              command[:readConcern] = Options::Mapper.transform_values_to_strings(
+                read_concern)
+            end
             command[:cursor] = cursor if cursor
-            command[:readConcern] = collection.read_concern if collection.read_concern
             command.merge!(Options::Mapper.transform_documents(options, MAPPINGS))
             command
           end
@@ -105,7 +123,14 @@ module Mongo
           end
 
           def batch_size_doc
-            (value = options[:batch_size] || view.batch_size) ?  { :batchSize => value } : {}
+            value = options[:batch_size] || view.batch_size
+            if value == 0 && write?
+              {}
+            elsif value
+              { :batchSize => value }
+            else
+              {}
+            end
           end
         end
       end

data/lib/mongo/collection/view/builder/find_command.rb

@@ -96,7 +96,10 @@ module Mongo
 
           def find_command
             document = BSON::Document.new('find' => collection.name, 'filter' => filter)
-            document[:readConcern] = collection.read_concern if collection.read_concern
+            if collection.read_concern
+              document[:readConcern] = Options::Mapper.transform_values_to_strings(
+                collection.read_concern)
+            end
             command = Options::Mapper.transform_documents(convert_flags(options), MAPPINGS, document)
             convert_limit_and_batch_size(command)
             command

data/lib/mongo/collection/view/builder/map_reduce.rb

@@ -139,7 +139,10 @@ module Mongo
               :query => filter,
               :out => { inline: 1 }
             )
-            command[:readConcern] = collection.read_concern if collection.read_concern
+            if collection.read_concern
+              command[:readConcern] = Options::Mapper.transform_values_to_strings(
+                collection.read_concern)
+            end
             command.merge!(view_options)
             command.merge!(Options::Mapper.transform_documents(options, MAPPINGS))
             command

data/lib/mongo/collection/view/change_stream.rb

@@ -94,8 +94,12 @@ module Mongo
           @changes_for = changes_for
           @change_stream_filters = pipeline && pipeline.dup
           @options = options && options.dup.freeze
-          @resume_token = @options[:resume_after]
           @start_after = @options[:start_after]
+
+          # The resume token tracked by the change stream, used only
+          # when there is no cursor, or no cursor resume token
+          @resume_token = @start_after || @options[:resume_after]
+
           create_cursor!
 
           # We send different parameters when we resume a change stream
@@ -121,26 +125,12 @@ module Mongo
         # @yieldparam [ BSON::Document ] Each change stream document.
         def each
           raise StopIteration.new if closed?
-          retried = false
-          begin
-            @cursor.each do |doc|
-              cache_resume_token(doc)
-              yield doc
-            end if block_given?
-            @cursor.to_enum
-          rescue Mongo::Error => e
-            if retried || !e.change_stream_resumable?
-              raise
-            end
-
-            retried = true
-            # Rerun initial aggregation.
-            # Any errors here will stop iteration and break out of this
-            # method
-            close
-            create_cursor!
-            retry
+          loop do
+            document = try_next
+            yield document if document
           end
+        rescue StopIteration => e
+          return self
         end
 
         # Return one document from the change stream, if one is available.
@@ -153,10 +143,7 @@ module Mongo
         # for changes from the server, and if no changes are received
         # it will return nil.
         #
-        # @note This method is experimental and subject to change.
-        #
         # @return [ BSON::Document | nil ] A change stream document.
-        # @api experimental
         # @since 2.6.0
         def try_next
           raise StopIteration.new if closed?
@@ -165,27 +152,28 @@ module Mongo
           begin
             doc = @cursor.try_next
           rescue Mongo::Error => e
-            unless e.change_stream_resumable?
+            if retried || !e.change_stream_resumable?
               raise
             end
 
-            if retried
-              # Rerun initial aggregation.
-              # Any errors here will stop iteration and break out of this
-              # method
-              close
-              create_cursor!
-              retried = false
-              doc = @cursor.try_next
-            else
-              # Attempt to retry a getMore once
-              retried = true
-              retry
-            end
+            retried = true
+            # Rerun initial aggregation.
+            # Any errors here will stop iteration and break out of this
+            # method
+
+            # Save cursor's resume token so we can use it
+            # to create a new cursor
+            @resume_token = @cursor.resume_token
+
+            close
+            create_cursor!
+            retry
           end
 
-          if doc
-            cache_resume_token(doc)
+          # We need to verify each doc has an _id, so we
+          # have a resume token to work with
+          if doc && doc['_id'].nil?
+            raise Error::MissingResumeToken
           end
           doc
         end
@@ -238,7 +226,21 @@ module Mongo
         # @since 2.5.0
         def inspect
           "#<Mongo::Collection::View:ChangeStream:0x#{object_id} filters=#{@change_stream_filters} " +
-            "options=#{@options} resume_token=#{@resume_token}>"
+            "options=#{@options} resume_token=#{resume_token}>"
+        end
+
+        # Returns the resume token that the stream will
+        # use to automatically resume, if one exists.
+        #
+        # @example Get the change stream resume token.
+        #   stream.resume_token
+        #
+        # @return [ BSON::Document | nil ] The change stream resume token.
+        #
+        # @since 2.10.0
+        def resume_token
+          cursor_resume_token = @cursor.resume_token if @cursor
+          cursor_resume_token || @resume_token
         end
 
         private
@@ -255,15 +257,6 @@ module Mongo
           !for_cluster? && !for_database?
         end
 
-        def cache_resume_token(doc)
-          # Always record both resume token and operation time,
-          # in case we get an older or newer server during rolling
-          # upgrades/downgrades
-          unless @resume_token = (doc[:_id] && doc[:_id].dup)
-            raise Error::MissingResumeToken
-          end
-        end
-
         def create_cursor!
           # clear the cache because we may get a newer or an older server
           # (rolling upgrades)
@@ -271,7 +264,10 @@ module Mongo
 
           session = client.send(:get_session, @options)
           start_at_operation_time = nil
+          start_at_operation_time_supported = nil
           @cursor = read_with_retry_cursor(session, server_selector, view) do |server|
+            start_at_operation_time_supported = server.description.server_version_gte?('4.0')
+
             result = send_initial_query(server, session)
             if doc = result.replies.first && result.replies.first.documents.first
               start_at_operation_time = doc['operationTime']
@@ -286,6 +282,7 @@ module Mongo
             result
           end
           @start_at_operation_time = start_at_operation_time
+          @start_at_operation_time_supported = start_at_operation_time_supported
         end
 
         def pipeline
@@ -305,14 +302,11 @@ module Mongo
               # However, if the first getMore fails and the user didn't pass
               # a resume token we won't have a resume token to use.
               # Use start_at_operation time in this case
-              if @resume_token
-                # Spec says we need to remove startAtOperationTime if
-                # one was passed in by user, thus we won't forward it
-              elsif @start_after
-                # The spec says to set `resumeAfter` to the `startAfter` token and not to send
-                # either `startAfter` or `startAtOperationTime`.
-                @resume_token = @start_after
-              elsif start_at_operation_time_supported? && @start_at_operation_time
+              if resume_token
+                # Spec says we need to remove both startAtOperationTime and startAfter if
+                # either was passed in by user, thus we won't forward them
+                doc[:resumeAfter] = resume_token
+              elsif @start_at_operation_time_supported && @start_at_operation_time
                 # It is crucial to check @start_at_operation_time_supported
                 # here - we may have switched to an older server that
                 # does not support operation times and therefore shouldn't
@@ -327,6 +321,8 @@ module Mongo
             else
               if @start_after
                 doc[:startAfter] = @start_after
+              elsif resume_token
+                doc[:resumeAfter] = resume_token
               end
 
               if options[:start_at_operation_time]
@@ -334,7 +330,7 @@ module Mongo
                   options[:start_at_operation_time])
               end
             end
-            doc[:resumeAfter] = @resume_token if @resume_token
+
             doc[:allChangesForCluster] = true if for_cluster?
           end
         end
@@ -357,14 +353,6 @@ module Mongo
         def resuming?
           !!@resuming
         end
-
-        def start_at_operation_time_supported?
-          if @start_at_operation_time_supported.nil?
-            server = server_selector.select_server(cluster)
-            @start_at_operation_time_supported = server.description.max_wire_version >= 7
-          end
-          @start_at_operation_time_supported
-        end
       end
     end
   end

data/lib/mongo/collection/view/iterable.rb

@@ -37,8 +37,8 @@ module Mongo
         def each
           @cursor = nil
           session = client.send(:get_session, @options)
-          @cursor = if respond_to?(:out?, true) && out?
-            server = server_selector.select_server(cluster)
+          @cursor = if respond_to?(:write?, true) && write?
+            server = server_selector.select_server(cluster, nil, session)
             result = send_initial_query(server, session)
             Cursor.new(view, result, server, session: session)
           else

data/lib/mongo/collection/view/map_reduce.rb

@@ -68,7 +68,7 @@ module Mongo
         def each
           @cursor = nil
           session = client.send(:get_session, @options)
-          server = cluster.next_primary
+          server = cluster.next_primary(nil, session)
           result = send_initial_query(server, session)
           result = send_fetch_query(server, session) unless inline?
           @cursor = Cursor.new(view, result, server, session: session)
@@ -195,7 +195,8 @@ module Mongo
         # @since 2.5.0
         def execute
           view.send(:with_session, @options) do |session|
-            legacy_write_with_retry do |server|
+            write_concern = view.write_concern_with_session(session)
+            nro_write_with_retry(session, write_concern) do |server|
               send_initial_query(server, session)
             end
           end
@@ -233,8 +234,9 @@ module Mongo
 
         def send_initial_query(server, session)
           unless valid_server?(server)
-            log_warn("Rerouting the MapReduce operation to the primary server - #{server.summary} is not suitable")
-            server = cluster.next_primary
+            msg = "Rerouting the MapReduce operation to the primary server - #{server.summary} is not suitable"
+            log_warn(msg)
+            server = cluster.next_primary(nil, session)
           end
           validate_collation!(server)
           initial_query_op(session).execute(server)

data/lib/mongo/collection/view/readable.rb

@@ -138,7 +138,10 @@ module Mongo
           cmd[:skip] = opts[:skip] if opts[:skip]
           cmd[:hint] = opts[:hint] if opts[:hint]
           cmd[:limit] = opts[:limit] if opts[:limit]
-          cmd[:readConcern] = read_concern if read_concern
+          if read_concern
+            cmd[:readConcern] = Options::Mapper.transform_values_to_strings(
+              read_concern)
+          end
           cmd[:maxTimeMS] = opts[:max_time_ms] if opts[:max_time_ms]
           Mongo::Lint.validate_underscore_read_preference(opts[:read])
           read_pref = opts[:read] || read_preference
@@ -205,7 +208,10 @@ module Mongo
         def estimated_document_count(opts = {})
           cmd = { count: collection.name }
           cmd[:maxTimeMS] = opts[:max_time_ms] if opts[:max_time_ms]
-          cmd[:readConcern] = read_concern if read_concern
+          if read_concern
+            cmd[:readConcern] = Options::Mapper.transform_values_to_strings(
+              read_concern)
+          end
           Mongo::Lint.validate_underscore_read_preference(opts[:read])
           read_pref = opts[:read] || read_preference
           selector = ServerSelector.get(read_pref || server_selector)
@@ -242,7 +248,10 @@ module Mongo
                   :key => field_name.to_s,
                   :query => filter }
           cmd[:maxTimeMS] = opts[:max_time_ms] if opts[:max_time_ms]
-          cmd[:readConcern] = read_concern if read_concern
+          if read_concern
+            cmd[:readConcern] = Options::Mapper.transform_values_to_strings(
+              read_concern)
+          end
           Mongo::Lint.validate_underscore_read_preference(opts[:read])
           read_pref = opts[:read] || read_preference
           selector = ServerSelector.get(read_pref || server_selector)
@@ -533,12 +542,7 @@ module Mongo
           configure(:cursor_type, type)
         end
 
-        private
-
-        def collation(doc = nil)
-          configure(:collation, doc)
-        end
-
+        # @api private
         def read_concern
           if options[:session] && options[:session].in_transaction?
             options[:session].send(:txn_read_concern) || collection.client.read_concern
@@ -547,14 +551,30 @@ module Mongo
           end
         end
 
+        # @api private
         def read_preference
-          rp = if options[:session] && options[:session].in_transaction?
-            options[:session].txn_read_preference || collection.client.read_preference
-          else
-            @read_preference ||= (options[:read] || collection.read_preference)
+          @read_preference ||= begin
+            # Operation read preference is always respected, and has the
+            # highest priority. If we are in a transaction, we look at
+            # transaction read preference and default to client, ignoring
+            # collection read preference. If we are not in transaction we
+            # look at collection read preference which defaults to client.
+            rp = if options[:read]
+              options[:read]
+            elsif options[:session] && options[:session].in_transaction?
+              options[:session].txn_read_preference || collection.client.read_preference
+            else
+              collection.read_preference
+            end
+            Lint.validate_underscore_read_preference(rp)
+            rp
           end
-          Lint.validate_underscore_read_preference(rp)
-          rp
+        end
+
+        private
+
+        def collation(doc = nil)
+          configure(:collation, doc)
         end
 
         def server_selector
@@ -571,7 +591,7 @@ module Mongo
           else
             session = nil
           end
-          server = server_selector.select_server(cluster)
+          server = server_selector.select_server(cluster, nil, session)
           cmd = Operation::ParallelScan.new({
                   :coll_name => collection.name,
                   :db_name => database.name,