mongo 2.14.1 → 2.15.0.alpha

data/lib/mongo/client.rb

@@ -85,6 +85,7 @@ module Mongo
       :retry_writes,
       :scan,
       :sdam_proc,
+      :server_api,
       :server_selection_timeout,
       :socket_timeout,
       :ssl,
@@ -114,7 +115,16 @@ module Mongo
     # The compression algorithms supported by the driver.
     #
     # @since 2.5.0
-    VALID_COMPRESSORS = [ Mongo::Protocol::Compressed::ZLIB ].freeze
+    VALID_COMPRESSORS = [
+      Mongo::Protocol::Compressed::ZSTD,
+      Mongo::Protocol::Compressed::SNAPPY,
+      Mongo::Protocol::Compressed::ZLIB
+    ].freeze
+
+    # The known server API versions.
+    VALID_SERVER_API_VERSIONS = %w(
+      1
+    ).freeze
 
     # @return [ Mongo::Cluster ] cluster The cluster of servers for the client.
     attr_reader :cluster
@@ -223,7 +233,7 @@ module Mongo
     # @option options [ Array<String> ] :compressors A list of potential
     #   compressors to use, in order of preference. The driver chooses the
     #   first compressor that is also supported by the server. Currently the
-    #   driver only supports 'zlib'.
+    #   driver only supports 'zstd, 'snappy' and 'zlib'.
     # @option options [ true | false ] :direct_connection Whether to connect
     #   directly to the specified seed, bypassing topology discovery. Exactly
     #   one seed must be provided.
@@ -312,6 +322,11 @@ module Mongo
     #   in particular the cluster is nil at this time. sdam_proc should
     #   limit itself to calling #subscribe and #unsubscribe methods on the
     #   client only.
+    # @option options [ Hash ] :server_api The requested server API version.
+    #   This hash can have the following items:
+    #   - *:version* -- string
+    #   - *:strict* -- boolean
+    #   - *:deprecation_errors* -- boolean
     # @option options [ Integer ] :server_selection_timeout The timeout in seconds
     #   for selecting a server for an operation.
     # @option options [ Float ] :socket_timeout The timeout, in seconds, to
@@ -465,6 +480,18 @@ module Mongo
 
       options = self.class.canonicalize_ruby_options(options)
 
+      # The server API version is specified to be a string.
+      # However, it is very annoying to always provide the number 1 as a string,
+      # therefore cast to the string type here.
+      if server_api = options[:server_api]
+        if server_api.is_a?(Hash)
+          server_api = Options::Redacted.new(server_api)
+          if (version = server_api[:version]).is_a?(Integer)
+            options[:server_api] = server_api.merge(version: version.to_s)
+          end
+        end
+      end
+
       # Special handling for sdam_proc as it is only used during client
       # construction
       sdam_proc = options.delete(:sdam_proc)
@@ -499,7 +526,9 @@ module Mongo
       validate_options!(addresses)
       validate_authentication_options!
 
-      @database = Database.new(self, @options[:database], @options)
+      database_options = @options.dup
+      database_options.delete(:server_api)
+      @database = Database.new(self, @options[:database], database_options)
 
       # Temporarily set monitoring so that event subscriptions can be
       # set up without there being a cluster
@@ -697,9 +726,9 @@ module Mongo
     # @return [ Mongo::Client ] A new client instance.
     #
     # @since 2.0.0
-    def with(new_options = Options::Redacted.new)
+    def with(new_options = nil)
       clone.tap do |client|
-        opts = client.update_options(new_options)
+        opts = client.update_options(new_options || Options::Redacted.new)
         Database.create(client)
         # We can't use the same cluster if some options that would affect it
         # have changed.
@@ -726,6 +755,8 @@ module Mongo
     def update_options(new_options)
       old_options = @options
 
+      new_options = self.class.canonicalize_ruby_options(new_options || {})
+
       validate_new_options!(new_options).tap do |opts|
         # Our options are frozen
         options = @options.dup
@@ -1127,7 +1158,7 @@ module Mongo
     # The argument may contain a subset of options that the client will
     # eventually have; this method validates each of the provided options
     # but does not check for interactions between combinations of options.
-    def validate_new_options!(opts = Options::Redacted.new)
+    def validate_new_options!(opts)
       return Options::Redacted.new unless opts
       if opts[:read_concern]
         # Raise an error for non user-settable options
@@ -1146,6 +1177,23 @@ module Mongo
         end
       end
 
+      if server_api = opts[:server_api]
+        unless server_api.is_a?(Hash)
+          raise ArgumentError, ":server_api value must be a hash: #{server_api}"
+        end
+
+        extra_keys = server_api.keys - %w(version strict deprecation_errors)
+        unless extra_keys.empty?
+          raise ArgumentError, "Unknown keys under :server_api: #{extra_keys.map(&:inspect).join(', ')}"
+        end
+
+        if version = server_api[:version]
+          unless VALID_SERVER_API_VERSIONS.include?(version)
+            raise ArgumentError, "Unknown server API version: #{version}"
+          end
+        end
+      end
+
       Lint.validate_underscore_read_preference(opts[:read])
       Lint.validate_read_concern_option(opts[:read_concern])
       opts.each.inject(Options::Redacted.new) do |_options, (k, v)|
@@ -1155,6 +1203,15 @@ module Mongo
           validate_read!(key, opts)
           if key == :compressors
             compressors = valid_compressors(v)
+
+            if compressors.include?('snappy')
+              validate_snappy_compression!
+            end
+
+            if compressors.include?('zstd')
+              validate_zstd_compression!
+            end
+
             _options[key] = compressors unless compressors.empty?
           else
             _options[key] = v
@@ -1311,11 +1368,30 @@ module Mongo
                        "This compressor will not be used.")
           false
         else
+
           true
         end
       end
     end
 
+    def validate_snappy_compression!
+      return if defined?(Snappy)
+      require 'snappy'
+    rescue LoadError => e
+      raise Error::UnmetDependency, "Cannot enable snappy compression because the snappy gem " \
+        "has not been installed. Add \"gem 'snappy'\" to your Gemfile and run " \
+        "\"bundle install\" to install the gem. (#{e.class}: #{e})"
+    end
+
+    def validate_zstd_compression!
+      return if defined?(Zstd)
+      require 'zstd-ruby'
+    rescue LoadError => e
+      raise Error::UnmetDependency, "Cannot enable zstd compression because the zstd-ruby gem " \
+        "has not been installed. Add \"gem 'zstd-ruby'\" to your Gemfile and run " \
+        "\"bundle install\" to install the gem. (#{e.class}: #{e})"
+    end
+
     def validate_max_min_pool_size!(option, opts)
       if option == :min_pool_size && opts[:min_pool_size]
         max = opts[:max_pool_size] || Server::ConnectionPool::DEFAULT_MAX_SIZE

data/lib/mongo/cluster/reapers/cursor_reaper.rb

@@ -130,16 +130,20 @@ module Mongo
         end
 
         to_kill_copy.each do |server, op_specs|
+          options = {
+            server_api: server.options[:server_api],
+          }
+          context = Operation::Context.new(options: options)
           op_specs.each do |op_spec|
             if server.features.find_command_enabled?
               Cursor::Builder::KillCursorsCommand.update_cursors(op_spec, active_cursors_copy.to_a)
               if Cursor::Builder::KillCursorsCommand.get_cursors_list(op_spec).size > 0
-                Operation::KillCursors.new(op_spec).execute(server, client: nil)
+                Operation::KillCursors.new(op_spec).execute(server, context: context)
               end
             else
               Cursor::Builder::OpKillCursors.update_cursors(op_spec, active_cursors_copy.to_a)
               if Cursor::Builder::OpKillCursors.get_cursors_list(op_spec).size > 0
-                Operation::KillCursors.new(op_spec).execute(server, client: nil)
+                Operation::KillCursors.new(op_spec).execute(server, context: context)
               end
             end
           end

data/lib/mongo/cluster.rb

@@ -107,6 +107,11 @@ module Mongo
     #   for the server monitor to refresh its description via ismaster.
     # @option options [ Hash ] :resolv_options For internal driver use only.
     #   Options to pass through to Resolv::DNS constructor for SRV lookups.
+    # @option options [ Hash ] :server_api The requested server API version.
+    #   This hash can have the following items:
+    #   - *:version* -- string
+    #   - *:strict* -- boolean
+    #   - *:deprecation_errors* -- boolean
     #
     # @since 2.0.0
     def initialize(seeds, monitoring, options = Options::Redacted.new)
@@ -129,7 +134,9 @@ module Mongo
       @servers = []
       @monitoring = monitoring
       @event_listeners = Event::Listeners.new
-      @app_metadata = Server::AppMetadata.new(@options)
+      @app_metadata = Server::AppMetadata.new(@options.merge(purpose: :application))
+      @monitor_app_metadata = Server::Monitor::AppMetadata.new(@options.merge(purpose: :monitor))
+      @push_monitor_app_metadata = Server::Monitor::AppMetadata.new(@options.merge(purpose: :push_monitor))
       @cluster_time_lock = Mutex.new
       @cluster_time = nil
       @srv_monitor_lock = Mutex.new
@@ -241,7 +248,11 @@ module Mongo
           # the servers list above and the wait call below, we should not
           # wait for the full remaining time - wait for up to 1 second, then
           # recheck the state.
-          server_selection_semaphore.wait([time_remaining, 1].min)
+          begin
+            server_selection_semaphore.wait([time_remaining, 1].min)
+          rescue ::Timeout::Error
+            # nothing
+          end
         end
       end
 
@@ -285,6 +296,12 @@ module Mongo
     # @since 2.4.0
     attr_reader :app_metadata
 
+    # @api private
+    attr_reader :monitor_app_metadata
+
+    # @api private
+    attr_reader :push_monitor_app_metadata
+
     # @return [ Array<String> ] The addresses of seed servers. Contains
     #   addresses that were given to Cluster when it was instantiated, not
     #   current addresses that the cluster is using as a result of SDAM.

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

@@ -134,7 +134,7 @@ module Mongo
             server = cluster.next_primary(nil, session)
           end
           validate_collation!(server)
-          initial_query_op(session).execute(server, client: client)
+          initial_query_op(session).execute(server, context: Operation::Context.new(client: client, session: session))
         end
 
         def validate_collation!(server)

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

@@ -346,7 +346,7 @@ module Mongo
         end
 
         def send_initial_query(server, session)
-          initial_query_op(session).execute(server, client: client)
+          initial_query_op(session).execute(server, context: Operation::Context.new(client: client, session: session))
         end
 
         def time_to_bson_timestamp(time)

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

@@ -35,28 +35,18 @@ module Mongo
         #
         # @yieldparam [ Hash ] Each matching document.
         def each
-          # If the caching cursor is closed and was not fully iterated,
-          # the documents we have in it are not the complete result set and
-          # we have no way of completing that iteration.
-          # Therefore, discard that cursor and start iteration again.
-          # The case of the caching cursor not being closed and not having
-          # been fully iterated isn't tested - see RUBY-2773.
-          @cursor = if use_query_cache? && cached_cursor && (
-            cached_cursor.fully_iterated? || !cached_cursor.closed?
-          )
+          @cursor = if use_query_cache? && cached_cursor
             cached_cursor
           else
             session = client.send(:get_session, @options)
-            select_cursor(session).tap do |cursor|
-              if use_query_cache?
-                # No need to store the cursor in the query cache if there is
-                # already a cached cursor stored at this key.
-                QueryCache.set(cursor, **cache_options)
-              end
-            end
+            select_cursor(session)
           end
 
           if use_query_cache?
+            # No need to store the cursor in the query cache if there is
+            # already a cached cursor stored at this key.
+            QueryCache.set(@cursor, **cache_options) unless cached_cursor
+
             # If a query with a limit is performed, the query cache will
             # re-use results from an earlier query with the same or larger
             # limit, and then impose the lower limit during iteration.
@@ -167,7 +157,7 @@ module Mongo
 
         def send_initial_query(server, session = nil)
           validate_collation!(server, collation)
-          initial_query_op(server, session).execute(server, client: client)
+          initial_query_op(server, session).execute(server, context: Operation::Context.new(client: client, session: session))
         end
 
         def use_query_cache?

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

@@ -242,7 +242,7 @@ module Mongo
             server = cluster.next_primary(nil, session)
           end
           validate_collation!(server)
-          initial_query_op(session).execute(server, client: client)
+          initial_query_op(session).execute(server, context: Operation::Context.new(client: client, session: session))
         end
 
         def fetch_query_spec
@@ -262,7 +262,7 @@ module Mongo
         end
 
         def send_fetch_query(server, session)
-          fetch_query_op(server, session).execute(server, client: client)
+          fetch_query_op(server, session).execute(server, context: Operation::Context.new(client: client, session: session))
         end
 
         def validate_collation!(server)

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

@@ -172,8 +172,8 @@ module Mongo
                                      :db_name => database.name,
                                      :options => {:limit => -1},
                                      :read => read_pref,
-                                     :session => session
-              ).execute(server, client: client)
+                                     :session => session,
+              ).execute(server, context: Operation::Context.new(client: client, session: session))
             end.n.to_i
           end
         end
@@ -230,24 +230,46 @@ module Mongo
             raise ArgumentError, "Cannot call estimated_document_count when querying with a filter"
           end
 
-          cmd = { count: collection.name }
-          cmd[:maxTimeMS] = opts[:max_time_ms] if opts[:max_time_ms]
-          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)
           with_session(opts) do |session|
+            context = Operation::Context.new(client: client, session: session)
             read_with_retry(session, selector) do |server|
-              Operation::Count.new(
-                selector: cmd,
-                db_name: database.name,
-                read: read_pref,
-                session: session
-              ).execute(server, client: client)
-            end.n.to_i
+              if server.description.server_version_gte?('5.0')
+                pipeline = [
+                  {'$collStats' => {'count' => {}}},
+                  {'$group' => {'_id' => 1, 'n' => {'$sum' => '$count'}}},
+                ]
+                spec = Builder::Aggregation.new(pipeline, self, options.merge(session: session)).specification
+                result = Operation::Aggregate.new(spec).execute(server, context: context)
+                result.documents.first.fetch('n')
+              else
+                cmd = { count: collection.name }
+                cmd[:maxTimeMS] = opts[:max_time_ms] if opts[:max_time_ms]
+                if read_concern
+                  cmd[:readConcern] = Options::Mapper.transform_values_to_strings(
+                    read_concern)
+                end
+                result = Operation::Count.new(
+                  selector: cmd,
+                  db_name: database.name,
+                  read: read_pref,
+                  session: session,
+                ).execute(server, context: context)
+                result.n.to_i
+              end
+            end
+          end
+        rescue Error::OperationFailure => exc
+          if exc.code == 26
+            # NamespaceNotFound
+            # This should only happen with the aggregation pipeline path
+            # (server 4.9+). Previous servers should return 0 for nonexistent
+            # collections.
+            0
+          else
+            raise
           end
         end
 
@@ -290,8 +312,8 @@ module Mongo
                                         :db_name => database.name,
                                         :options => {:limit => -1},
                                         :read => read_pref,
-                                        :session => session
-                                       }).execute(server, client: client)
+                                        :session => session,
+                                       }).execute(server, context: Operation::Context.new(client: client, session: session))
             end.first['values']
           end
         end
@@ -626,21 +648,21 @@ module Mongo
                   :read_concern => read_concern,
                   :session => session,
                 }.merge!(options))
-          cmd.execute(server, client: client).cursor_ids.map do |cursor_id|
+          cmd.execute(server, context: Operation::Context.new(client: client, session: session)).cursor_ids.map do |cursor_id|
             result = if server.with_connection { |connection| connection.features }.find_command_enabled?
               Operation::GetMore.new({
                 :selector => {:getMore => BSON::Int64.new(cursor_id),
                              :collection => collection.name},
                 :db_name => database.name,
                 :session => session,
-              }).execute(server, client: client)
+              }).execute(server, context: Operation::Context.new(client: client, session: session))
              else
               Operation::GetMore.new({
                 :to_return => 0,
                 :cursor_id => BSON::Int64.new(cursor_id),
                 :db_name => database.name,
                 :coll_name => collection.name
-              }).execute(server, client: client)
+              }).execute(server, context: Operation::Context.new(client: client, session: session))
             end
             Cursor.new(self, result, server, session: session)
           end

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

@@ -69,8 +69,8 @@ module Mongo
                   :selector => cmd,
                   :db_name => database.name,
                   :session => session,
-                  :txn_num => txn_num
-              ).execute(server, client: client)
+                  :txn_num => txn_num,
+              ).execute(server, context: Operation::Context.new(client: client, session: session))
             end
           end.first['value']
         end
@@ -154,8 +154,8 @@ module Mongo
                   :selector => cmd,
                   :db_name => database.name,
                   :session => session,
-                  :txn_num => txn_num
-              ).execute(server, client: client)
+                  :txn_num => txn_num,
+              ).execute(server, context: Operation::Context.new(client: client, session: session))
             end
           end.first['value']
           value unless value.nil? || value.empty?
@@ -198,8 +198,8 @@ module Mongo
                   :coll_name => collection.name,
                   :write_concern => write_concern,
                   :bypass_document_validation => !!opts[:bypass_document_validation],
-                  :session => session
-              ).execute(server, client: client)
+                  :session => session,
+              ).execute(server, context: Operation::Context.new(client: client, session: session))
             end
           end
         end
@@ -242,8 +242,8 @@ module Mongo
                   :write_concern => write_concern,
                   :bypass_document_validation => !!opts[:bypass_document_validation],
                   :session => session,
-                  :txn_num => txn_num
-              ).execute(server, client: client)
+                  :txn_num => txn_num,
+              ).execute(server, context: Operation::Context.new(client: client, session: session))
             end
           end
         end
@@ -298,8 +298,8 @@ module Mongo
                   :write_concern => write_concern,
                   :bypass_document_validation => !!opts[:bypass_document_validation],
                   :session => session,
-                  :txn_num => txn_num
-              ).execute(server, client: client)
+                  :txn_num => txn_num,
+              ).execute(server, context: Operation::Context.new(client: client, session: session))
             end
           end
         end
@@ -355,8 +355,8 @@ module Mongo
                   :coll_name => collection.name,
                   :write_concern => write_concern,
                   :bypass_document_validation => !!opts[:bypass_document_validation],
-                  :session => session
-              ).execute(server, client: client)
+                  :session => session,
+              ).execute(server, context: Operation::Context.new(client: client, session: session))
             end
           end
         end
@@ -412,8 +412,8 @@ module Mongo
                   :write_concern => write_concern,
                   :bypass_document_validation => !!opts[:bypass_document_validation],
                   :session => session,
-                  :txn_num => txn_num
-              ).execute(server, client: client)
+                  :txn_num => txn_num,
+              ).execute(server, context: Operation::Context.new(client: client, session: session))
             end
           end
         end

data/lib/mongo/collection.rb

@@ -254,8 +254,8 @@ module Mongo
                                 selector: operation,
                                 db_name: database.name,
                                 write_concern: write_concern,
-                                session: session
-                                }).execute(server, client: client)
+                                session: session,
+                                }).execute(server, context: Operation::Context.new(client: client, session: session))
       end
     end
 
@@ -287,8 +287,8 @@ module Mongo
                               selector: { :drop => name },
                               db_name: database.name,
                               write_concern: write_concern,
-                              session: session
-                              }).execute(next_primary(nil, session), client: client)
+                              session: session,
+                              }).execute(next_primary(nil, session), context: Operation::Context.new(client: client, session: session))
       end
     rescue Error::OperationFailure => ex
       # NamespaceNotFound
@@ -579,8 +579,8 @@ module Mongo
             :options => opts,
             :id_generator => client.options[:id_generator],
             :session => session,
-            :txn_num => txn_num
-          ).execute(server, client: client)
+            :txn_num => txn_num,
+          ).execute(server, context: Operation::Context.new(client: client, session: session))
         end
       end
     end

data/lib/mongo/cursor.rb

@@ -209,12 +209,10 @@ module Mongo
         unless closed?
           if exhausted?
             close
-            @fully_iterated = true
             raise StopIteration
           end
           @documents = get_more
         else
-          @fully_iterated = true
           raise StopIteration
         end
       else
@@ -231,9 +229,6 @@ 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
@@ -275,7 +270,7 @@ module Mongo
 
       unregister
       read_with_one_retry do
-        kill_cursors_operation.execute(@server, client: client)
+        kill_cursors_operation.execute(@server, context: Operation::Context.new(client: client, session: @session))
       end
 
       nil
@@ -350,12 +345,7 @@ 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, client: client))
-    end
-
-    # @api private
-    def fully_iterated?
-      !!@fully_iterated
+      process(get_more_operation.execute(@server, context: Operation::Context.new(client: client, session: @session)))
     end
 
     private

data/lib/mongo/database/view.rb

@@ -189,7 +189,7 @@ module Mongo
       end
 
       def send_initial_query(server, session, options = {})
-        initial_query_op(session, options).execute(server, client: client)
+        initial_query_op(session, options).execute(server, context: Operation::Context.new(client: client, session: session))
       end
     end
   end

data/lib/mongo/database.rb

@@ -104,6 +104,9 @@ module Mongo
     #
     # @since 2.0.0
     def [](collection_name, options = {})
+      if options[:server_api]
+        raise ArgumentError, 'The :server_api option cannot be specified for collection objects. It can only be specified on Client level'
+      end
       Collection.new(self, collection_name, options)
     end
     alias_method :collection, :[]
@@ -219,7 +222,9 @@ module Mongo
           :session => session
         )
 
-        op.execute(server, client: client, options: execution_opts)
+        op.execute(server,
+          context: Operation::Context.new(client: client, session: session),
+          options: execution_opts)
       end
     end
 
@@ -250,7 +255,7 @@ module Mongo
             :db_name => name,
             :read => preference,
             :session => session
-          }).execute(server, client: client)
+          }).execute(server, context: Operation::Context.new(client: client, session: session))
         end
       end
     end
@@ -281,7 +286,7 @@ module Mongo
           db_name: name,
           write_concern: write_concern,
           session: session
-        }).execute(next_primary(nil, session), client: client)
+        }).execute(next_primary(nil, session), context: Operation::Context.new(client: client, session: session))
       end
     end