mongo 2.8.0 → 2.9.0.rc0

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

@@ -37,15 +37,22 @@ module Mongo
         def each
           @cursor = nil
           session = client.send(:get_session, @options)
-          read_with_retry(session) do
+          @cursor = if respond_to?(:out?, true) && out?
             server = server_selector.select_server(cluster)
             result = send_initial_query(server, session)
-            @cursor = Cursor.new(view, result, server, session: session)
+            Cursor.new(view, result, server, session: session)
+          else
+            read_with_retry_cursor(session, server_selector, view) do |server|
+              send_initial_query(server, session)
+            end
+          end
+          if block_given?
+            @cursor.each do |doc|
+              yield doc
+            end
+          else
+            @cursor.to_enum
           end
-          @cursor.each do |doc|
-            yield doc
-          end if block_given?
-          @cursor.to_enum
         end
 
         # Stop the iteration by sending a KillCursors command to the server.

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

@@ -67,15 +67,17 @@ module Mongo
         def each
           @cursor = nil
           session = client.send(:get_session, @options)
-          legacy_write_with_retry do |server|
-            result = send_initial_query(server, session)
-            result = send_fetch_query(server, session) unless inline?
-            @cursor = Cursor.new(view, result, server, session: session)
+          server = cluster.next_primary
+          result = send_initial_query(server, session)
+          result = send_fetch_query(server, session) unless inline?
+          @cursor = Cursor.new(view, result, server, session: session)
+          if block_given?
+            @cursor.each do |doc|
+              yield doc
+            end
+          else
+            @cursor.to_enum
           end
-          @cursor.each do |doc|
-            yield doc
-          end if block_given?
-          @cursor.to_enum
         end
 
         # Set or get the finalize function for the operation.
@@ -106,8 +108,8 @@ module Mongo
         # @since 2.0.0
         def initialize(view, map, reduce, options = {})
           @view = view
-          @map_function = map.freeze
-          @reduce_function = reduce.freeze
+          @map_function = map.dup.freeze
+          @reduce_function = reduce.dup.freeze
           @options = BSON::Document.new(options).freeze
         end
 

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

@@ -138,23 +138,22 @@ 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
           cmd[:maxTimeMS] = opts[:max_time_ms] if opts[:max_time_ms]
-          cmd[:readConcern] = collection.read_concern if collection.read_concern
           Mongo::Lint.validate_underscore_read_preference(opts[:read])
           read_pref = opts[:read] || read_preference
           selector = ServerSelector.get(read_pref || server_selector)
           with_session(opts) do |session|
-            read_with_retry(session) do
-              server = selector.select_server(cluster)
+            read_with_retry(session, selector) do |server|
               apply_collation!(cmd, server, opts)
-              Operation::Count.new({
+              Operation::Count.new(
                                      :selector => cmd,
                                      :db_name => database.name,
                                      :options => {:limit => -1},
                                      :read => read_pref,
                                      :session => session
-                                    }).execute(server)
-              end.n.to_i
+              ).execute(server)
+            end.n.to_i
           end
         end
 
@@ -181,7 +180,7 @@ module Mongo
           pipeline = [:'$match' => filter]
           pipeline << { :'$skip' => opts[:skip] } if opts[:skip]
           pipeline << { :'$limit' => opts[:limit] } if opts[:limit]
-          pipeline << { :'$group' => { _id: nil, n: { :'$sum' => 1 } } }
+          pipeline << { :'$group' => { _id: 1, n: { :'$sum' => 1 } } }
 
           opts.select! { |k, _| [:hint, :max_time_ms, :read, :collation, :session].include?(k) }
           first = aggregate(pipeline, opts).first
@@ -206,13 +205,12 @@ module Mongo
         def estimated_document_count(opts = {})
           cmd = { count: collection.name }
           cmd[:maxTimeMS] = opts[:max_time_ms] if opts[:max_time_ms]
-          cmd[:readConcern] = collection.read_concern if collection.read_concern
+          cmd[:readConcern] = read_concern if read_concern
           Mongo::Lint.validate_underscore_read_preference(opts[:read])
           read_pref = opts[:read] || read_preference
           selector = ServerSelector.get(read_pref || server_selector)
           with_session(opts) do |session|
-            read_with_retry(session) do
-              server = selector.select_server(cluster)
+            read_with_retry(session, selector) do |server|
               Operation::Count.new(
                 selector: cmd,
                 db_name: database.name,
@@ -244,13 +242,12 @@ module Mongo
                   :key => field_name.to_s,
                   :query => filter }
           cmd[:maxTimeMS] = opts[:max_time_ms] if opts[:max_time_ms]
-          cmd[:readConcern] = collection.read_concern if collection.read_concern
+          cmd[:readConcern] = read_concern if read_concern
           Mongo::Lint.validate_underscore_read_preference(opts[:read])
           read_pref = opts[:read] || read_preference
           selector = ServerSelector.get(read_pref || server_selector)
           with_session(opts) do |session|
-            read_with_retry(session) do
-              server = selector.select_server(cluster)
+            read_with_retry(session, selector) do |server|
               apply_collation!(cmd, server, opts)
               Operation::Distinct.new({
                                         :selector => cmd,
@@ -542,6 +539,14 @@ module Mongo
           configure(:collation, doc)
         end
 
+        def read_concern
+          if options[:session] && options[:session].in_transaction?
+            options[:session].send(:txn_read_concern) || collection.client.read_concern
+          else
+            collection.read_concern
+          end
+        end
+
         def read_preference
           rp = if options[:session] && options[:session].in_transaction?
             options[:session].txn_read_preference || collection.client.read_preference
@@ -571,7 +576,7 @@ module Mongo
                   :coll_name => collection.name,
                   :db_name => database.name,
                   :cursor_count => cursor_count,
-                  :read_concern => collection.read_concern,
+                  :read_concern => read_concern,
                   :session => session,
                 }.merge!(options))
           cmd.execute(server).cursor_ids.map do |cursor_id|

data/lib/mongo/cursor.rb

@@ -53,7 +53,10 @@ module Mongo
     # @param [ Hash ] options The cursor options.
     #
     # @option options [ true, false ] :disable_retry Whether to disable
-    #   retrying on error when sending getMores.
+    #   retrying on error when sending getMore operations (deprecated, getMore
+    #   operations are no longer retried)
+    # @option options [ true, false ] :retry_reads Retry reads (following
+    #   the modern mechanism), default is true
     #
     # @since 2.0.0
     def initialize(view, result, server, options = {})
@@ -75,6 +78,8 @@ module Mongo
       end
     end
 
+    # @api private
+    attr_reader :server
 
     # Finalize the cursor for garbage collection. Schedules this cursor to be included
     # in a killCursors operation executed by the Cluster's CursorReaper.
@@ -237,13 +242,12 @@ module Mongo
     end
 
     def get_more
-      if @options[:disable_retry]
-        process(get_more_operation.execute(@server))
-      else
-        read_with_retry(@session) do
-          process(get_more_operation.execute(@server))
-        end
-      end
+      # Modern retryable reads specification prohibits retrying getMores.
+      # Legacy retryable read logic used to retry getMores, but since
+      # 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))
     end
 
     def get_more_operation

data/lib/mongo/database.rb

@@ -22,6 +22,7 @@ module Mongo
   # @since 2.0.0
   class Database
     extend Forwardable
+    include Retryable
 
     # The admin database name.
     #
@@ -67,6 +68,7 @@ module Mongo
                    :cluster,
                    :read_preference,
                    :server_selector,
+                   :read_concern,
                    :write_concern
 
     # @return [ Mongo::Server ] Get the primary server from the cluster.
@@ -162,15 +164,16 @@ module Mongo
       txn_read_pref ||= opts[:read] || ServerSelector::PRIMARY
       Lint.validate_underscore_read_preference(txn_read_pref)
       preference = ServerSelector.get(txn_read_pref)
-      server = preference.select_server(cluster)
 
       client.send(:with_session, opts) do |session|
-        Operation::Command.new({
-          :selector => operation.dup,
-          :db_name => name,
-          :read => preference,
-          :session => session
-        }).execute(server)
+        read_with_retry(session, preference) do |server|
+          Operation::Command.new({
+            :selector => operation.dup,
+            :db_name => name,
+            :read => preference,
+            :session => session
+          }).execute(server)
+        end
       end
     end
 

data/lib/mongo/database/view.rb

@@ -21,6 +21,7 @@ module Mongo
     class View
       extend Forwardable
       include Enumerable
+      include Retryable
 
       def_delegators :@database, :cluster, :read_preference, :client
       def_delegators :cluster, :next_primary
@@ -50,11 +51,12 @@ module Mongo
       # @since 2.0.0
       def collection_names(options = {})
         @batch_size = options[:batch_size]
-        server = next_primary(false)
-        @limit = -1 if server.features.list_collections_enabled?
         session = client.send(:get_session, options)
-        collections_info(server, session, name_only: true).collect do |info|
-          if server.features.list_collections_enabled?
+        cursor = read_with_retry_cursor(session, ServerSelector.get(mode: :primary), self) do |server|
+          send_initial_query(server, session, name_only: true)
+        end
+        cursor.map do |info|
+          if cursor.server.features.list_collections_enabled?
             info[Database::NAME]
           else
             (info[Database::NAME] &&
@@ -73,7 +75,7 @@ module Mongo
       # @since 2.0.5
       def list_collections
         session = client.send(:get_session)
-        collections_info(next_primary(false), session)
+        collections_info(session, ServerSelector.get(mode: :primary))
       end
 
       # Create the new database view.
@@ -93,12 +95,17 @@ module Mongo
 
       private
 
-      def collections_info(server, session, options = {}, &block)
-        cursor = Cursor.new(self, send_initial_query(server, session, options), server, session: session)
-        cursor.each do |doc|
-          yield doc
-        end if block_given?
-        cursor.to_enum
+      def collections_info(session, server_selector, options = {}, &block)
+        cursor = read_with_retry_cursor(session, server_selector, self) do |server|
+          send_initial_query(server, session, options)
+        end
+        if block_given?
+          cursor.each do |doc|
+            yield doc
+          end
+        else
+          cursor.to_enum
+        end
       end
 
       def collections_info_spec(session, options = {})

data/lib/mongo/error.rb

@@ -12,8 +12,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require 'forwardable'
-
 module Mongo
   # Base error class for all Mongo related errors.
   #
@@ -140,6 +138,7 @@ require 'mongo/error/write_retryable'
 require 'mongo/error/change_stream_resumable'
 require 'mongo/error/bulk_write_error'
 require 'mongo/error/closed_stream'
+require 'mongo/error/connection_check_out_timeout'
 require 'mongo/error/extra_file_chunk'
 require 'mongo/error/file_not_found'
 require 'mongo/error/operation_failure'
@@ -173,6 +172,7 @@ require 'mongo/error/need_primary_server'
 require 'mongo/error/no_server_available'
 require 'mongo/error/no_srv_records'
 require 'mongo/error/session_ended'
+require 'mongo/error/pool_closed_error'
 require 'mongo/error/socket_error'
 require 'mongo/error/socket_timeout_error'
 require 'mongo/error/failed_stringprep_validation'

data/lib/mongo/error/connection_check_out_timeout.rb

@@ -0,0 +1,49 @@
+# Copyright (C) 2019 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
+
+    # Exception raised when trying to check out a connection from a connection
+    # pool, the pool is at its max size and no connections become available
+    # within the configured wait timeout.
+    #
+    # @note For backwards compatibility reasons this class derives from
+    #   Timeout::Error rather than Mongo::Error.
+    #
+    # @since 2.9.0
+    class ConnectionCheckOutTimeout < ::Timeout::Error
+
+      # @return [ Mongo::Address ] address The address of the server the
+      #   pool's connections connect to.
+      #
+      # @since 2.9.0
+      attr_reader :address
+
+      # Instantiate the new exception.
+      #
+      # @param [ Address ] address
+      # @param [ Float ] wait_timeout
+      #
+      # @since 2.9.0
+      # @api private
+      def initialize(address, wait_timeout)
+        @address = address
+
+        super("Timed out when attempting to check out a connection from pool with address " +
+                "#{address} after #{wait_timeout} sec")
+      end
+    end
+  end
+end

data/lib/mongo/error/operation_failure.rb

@@ -78,24 +78,24 @@ module Mongo
       # @since 2.6.0
       attr_reader :code_name
 
-      # Can the read operation that caused the error be retried?
+      # Whether the error is a retryable error according to the legacy read retry
+      # logic.
       #
-      # @example Is the error retryable?
-      #   error.retryable?
-      #
-      # @return [ true, false ] Whether the error is retryable.
+      # @return [ true, false ]
       #
       # @since 2.1.1
+      # @deprecated
       def retryable?
         RETRY_MESSAGES.any?{ |m| message.include?(m) }
       end
 
-      # Can the write operation that caused the error be retried?
+      # Whether the error is a retryable error according to the modern retryable
+      # reads and retryable writes specifications.
       #
-      # @example Is the error retryable for writes?
-      #   error.write_retryable?
+      # This method is also used by the legacy retryable write logic to determine
+      # whether an error is a retryable one.
       #
-      # @return [ true, false ] Whether the error is retryable.
+      # @return [ true, false ]
       #
       # @since 2.4.2
       def write_retryable?

data/lib/mongo/error/parser.rb

@@ -72,15 +72,33 @@ module Mongo
 
       # Create the new parser with the returned document.
       #
+      # In legacy mode, the code and codeName fields of the document are not
+      # examined because the status (ok: 1) is not part of the document and
+      # there is no way to distinguish successful from failed responses using
+      # the document itself, and a successful response may legitimately have
+      # {code: 123, codeName: 'foo'} as the contents of a user-inserted
+      # document. The legacy server versions do not fill out code nor codeName
+      # thus not reading them does not lose information.
+      #
       # @example Create the new parser.
       #   Parser.new({ 'errmsg' => 'failed' })
       #
       # @param [ BSON::Document ] document The returned document.
+      # @param [ Array<Protocol::Message> ] replies The message replies.
+      # @param [ Hash ] options The options.
+      #
+      # @option options [ true | false ] :legacy Whether document and replies
+      #   are from a legacy (pre-3.2) response
       #
       # @since 2.0.0
-      def initialize(document, replies = nil)
+      def initialize(document, replies = nil, options = nil)
         @document = document || {}
         @replies = replies
+        @options = if options
+          options.dup
+        else
+          {}
+        end.freeze
         parse!
       end
 
@@ -130,8 +148,12 @@ module Mongo
       end
 
       def parse_code
-        @code = document['code']
-        @code_name = document['codeName']
+        if document['ok'] == 1 || @options[:legacy]
+          @code = @code_name = nil
+        else
+          @code = document['code']
+          @code_name = document['codeName']
+        end
 
         # Since there is only room for one code, do not replace
         # codes of the top level response with write concern error codes.