mongo 2.16.4 → 2.17.0

data/lib/mongo/database.rb

@@ -253,12 +253,12 @@ module Mongo
 
       client.send(:with_session, opts) do |session|
         read_with_retry(session, preference) do |server|
-          Operation::Command.new({
-            :selector => operation.dup,
-            :db_name => name,
-            :read => preference,
-            :session => session
-          }).execute(server, context: Operation::Context.new(client: client, session: session))
+          Operation::Command.new(
+            selector: operation.dup,
+            db_name: name,
+            read: preference,
+            session: session,
+          ).execute(server, context: Operation::Context.new(client: client, session: session))
         end
       end
     end

data/lib/mongo/error/snapshot_session_invalid_server_version.rb

@@ -0,0 +1,31 @@
+# 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
+
+    # Exception raised if an operation using a snapshot session is
+    # directed to a pre-5.0 server.
+    class SnapshotSessionInvalidServerVersion < Error
+
+      # Instantiate the new exception.
+      def initialize
+        super("Snapshot reads require MongoDB 5.0 or later")
+      end
+    end
+  end
+end

data/lib/mongo/error/snapshot_session_transaction_prohibited.rb

@@ -0,0 +1,30 @@
+# 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
+
+    # Exception raised if a transaction is attempted on a snapshot session.
+    class SnapshotSessionTransactionProhibited < Error
+
+      # Instantiate the new exception.
+      def initialize
+        super("Transactions are not supported in snapshot sessions")
+      end
+    end
+  end
+end

data/lib/mongo/error.rb

@@ -223,6 +223,8 @@ require 'mongo/error/no_server_available'
 require 'mongo/error/no_srv_records'
 require 'mongo/error/session_ended'
 require 'mongo/error/sessions_not_supported'
+require 'mongo/error/snapshot_session_invalid_server_version'
+require 'mongo/error/snapshot_session_transaction_prohibited'
 require 'mongo/error/operation_failure'
 require 'mongo/error/pool_closed_error'
 require 'mongo/error/raise_original_error'

data/lib/mongo/operation/delete/op_msg.rb

@@ -37,7 +37,8 @@ module Mongo
           { delete: coll_name,
             Protocol::Msg::DATABASE_IDENTIFIER => db_name,
             ordered: ordered?,
-          }.tap do |selector|
+            let: spec[:let],
+          }.compact.tap do |selector|
             if hint = spec[:hint]
               validate_hint_on_update(connection, selector)
               selector[:hint] = hint

data/lib/mongo/operation/find/builder/command.rb

@@ -35,6 +35,7 @@ module Mongo
             comment: 'comment',
             filter: 'filter',
             hint: 'hint',
+            let: 'let',
             limit: 'limit',
             max_scan: 'maxScan',
             max_time_ms: 'maxTimeMS',

data/lib/mongo/operation/result.rb

@@ -429,6 +429,12 @@ module Mongo
         !!(first_document && first_document['writeConcernError'])
       end
 
+      def snapshot_timestamp
+        if doc = reply.documents.first
+          doc['cursor']&.[]('atClusterTime') || doc['atClusterTime']
+        end
+      end
+
       private
 
       def aggregate_returned_count

data/lib/mongo/operation/shared/executable.rb

@@ -43,6 +43,10 @@ module Mongo
                       session.pin_to_service(connection.service_id)
                     end
                   end
+
+                  if session.snapshot? && !session.snapshot_timestamp
+                    session.snapshot_timestamp = result.snapshot_timestamp
+                  end
                 end
                 process_result(result, connection)
               end

data/lib/mongo/operation/shared/sessions_supported.rb

@@ -199,8 +199,13 @@ module Mongo
           read_doc
         else
           # In replica sets, read preference is passed to the server if one
-          # is specified by the application, and there is no default.
-          read&.to_doc
+          # is specified by the application, except for primary read preferences.
+          read_doc = BSON::Document.new(read&.to_doc || {})
+          if [nil, 'primary'].include?(read_doc['mode'])
+            nil
+          else
+            read_doc
+          end
         end
 
         if read_doc
@@ -224,6 +229,17 @@ module Mongo
         then
           sel[:recoveryToken] = session.recovery_token
         end
+
+        if session.snapshot?
+          unless connection.description.server_version_gte?('5.0')
+            raise Error::SnapshotSessionInvalidServerVersion
+          end
+
+          sel[:readConcern] = {level: 'snapshot'}
+          if session.snapshot_timestamp
+            sel[:readConcern][:atClusterTime] = session.snapshot_timestamp
+          end
+        end
       end
 
       def build_message(connection, context)

data/lib/mongo/operation/update/op_msg.rb

@@ -37,7 +37,8 @@ module Mongo
           {
             update: coll_name,
             ordered: ordered?,
-          }
+            let: spec[:let]
+          }.compact
         end
 
         def message(connection)

data/lib/mongo/query_cache.rb

@@ -179,8 +179,7 @@ module Mongo
       #
       # @api private
       def get(**opts)
-        limit = normalized_limit(opts[:limit])
-
+        limit = opts[:limit]
         _namespace_key = namespace_key(**opts)
         _cache_key = cache_key(**opts)
 
@@ -190,7 +189,7 @@ module Mongo
         caching_cursor = namespace_hash[_cache_key]
         return nil unless caching_cursor
 
-        caching_cursor_limit = normalized_limit(caching_cursor.view.limit)
+        caching_cursor_limit = caching_cursor.view.limit
 
         # There are two scenarios in which a caching cursor could fulfill the
         # query:
@@ -200,7 +199,6 @@ module Mongo
         #
         # Otherwise, return nil because the stored cursor will not satisfy
         # the query.
-
         if limit && (caching_cursor_limit.nil? || caching_cursor_limit >= limit)
           caching_cursor
         elsif limit.nil? && caching_cursor_limit.nil?
@@ -210,14 +208,6 @@ module Mongo
         end
       end
 
-      def normalized_limit(limit)
-        return nil unless limit
-        # For the purposes of caching, a limit of 0 means no limit, as mongo treats it as such.
-        return nil if limit == 0
-        # For the purposes of caching, a negative limit is the same as as a positive limit.
-        limit.abs
-      end
-
       private
 
       def cache_key(**opts)

data/lib/mongo/server/description/features.rb

@@ -35,9 +35,11 @@ module Mongo
         # -  8 => 4.2
         # -  9 => 4.4
         # - 13 => 5.0
+        # - 14 => 5.1
         #
         # @since 2.0.0
         MAPPINGS = {
+          merge_out_on_secondary: 13,
           retryable_write_error_label: 9,
           commit_quorum: 9,
           # Server versions older than 4.2 do not reliably validate options
@@ -78,7 +80,7 @@ module Mongo
         # The wire protocol versions that this version of the driver supports.
         #
         # @since 2.0.0
-        DRIVER_WIRE_VERSIONS = (2..13).freeze
+        DRIVER_WIRE_VERSIONS = (6..14).freeze
 
         # Create the methods for each mapping to tell if they are supported.
         #

data/lib/mongo/server/monitor/connection.rb

@@ -227,21 +227,15 @@ module Mongo
         # @api private
         def check_document
           server_api = @app_metadata.server_api || options[:server_api]
-          doc = if hello_ok? || server_api
-            _doc = HELLO_DOC
+          if hello_ok? || server_api
+            doc = HELLO_DOC
             if server_api
-              _doc = _doc.merge(Utils.transform_server_api(server_api))
+              doc = doc.merge(Utils.transform_server_api(server_api))
             end
-            _doc
+            doc
           else
             LEGACY_HELLO_DOC
           end
-          # compressors must be set to maintain correct compression status
-          # in the server description. See RUBY-2427
-          if compressors = options[:compressors]
-            doc = doc.merge(compression: compressors)
-          end
-          doc
         end
 
         private

data/lib/mongo/server_selector/base.rb

@@ -162,6 +162,8 @@ module Mongo
       #   Deprecated and ignored.
       # @param [ Session | nil ] session Optional session to take into account
       #   for mongos pinning. Added in version 2.10.0.
+      # @param [ true | false ] write_aggregation Whether we need a server that
+      #   supports writing aggregations (e.g. with $merge/$out) on secondaries.
       #
       # @return [ Mongo::Server ] A server matching the server preference.
       #
@@ -172,7 +174,7 @@ module Mongo
       #   lint mode is enabled.
       #
       # @since 2.0.0
-      def select_server(cluster, ping = nil, session = nil)
+      def select_server(cluster, ping = nil, session = nil, write_aggregation: false)
         if cluster.topology.is_a?(Cluster::Topology::LoadBalanced)
           return cluster.servers.first
         end
@@ -243,7 +245,7 @@ module Mongo
 =end
 
         loop do
-          server = try_select_server(cluster)
+          server = try_select_server(cluster, write_aggregation: write_aggregation)
 
           if server
             unless cluster.topology.compatible?
@@ -294,11 +296,31 @@ module Mongo
       # Tries to find a suitable server, returns the server if one is available
       # or nil if there isn't a suitable server.
       #
+      # @param [ Mongo::Cluster ] cluster The cluster from which to select
+      #   an eligible server.
+      # @param [ true | false ] write_aggregation Whether we need a server that
+      #   supports writing aggregations (e.g. with $merge/$out) on secondaries.
+      #
       # @return [ Server | nil ] A suitable server, if one exists.
       #
       # @api private
-      def try_select_server(cluster)
-        servers = suitable_servers(cluster)
+      def try_select_server(cluster, write_aggregation: false)
+        servers = if write_aggregation && cluster.replica_set?
+          # 1. Check if ALL servers in cluster support secondary writes.
+          is_write_supported = cluster.servers.reduce(true) do |res, server|
+            res && server.features.merge_out_on_secondary_enabled?
+          end
+
+          if is_write_supported
+            # 2. If all servers support secondary writes, we respect read preference.
+            suitable_servers(cluster)
+          else
+            # 3. Otherwise we fallback to primary for replica set.
+            [cluster.servers.detect(&:primary?)]
+          end
+        else
+          suitable_servers(cluster)
+        end
 
         # This list of servers may be ordered in a specific way
         # by the selector (e.g. for secondary preferred, the first

data/lib/mongo/session.rb

@@ -56,10 +56,16 @@ module Mongo
     #   - *:mode* -- the read preference as a string or symbol; valid values are
     #     *:primary*, *:primary_preferred*, *:secondary*, *:secondary_preferred*
     #     and *:nearest*.
+    # @option options [ true | false ] :snapshot Set up the session for
+    #   snapshot reads.
     #
     # @since 2.5.0
     # @api private
     def initialize(server_session, client, options = {})
+      if options[:causal_consistency] && options[:snapshot]
+        raise ArgumentError, ':causal_consistency and :snapshot options cannot be both set on a session'
+      end
+
       @server_session = server_session
       options = options.dup
 
@@ -83,6 +89,12 @@ module Mongo
       @client.cluster
     end
 
+    # @return [ true | false ] Whether the session is configured for snapshot
+    #   reads.
+    def snapshot?
+      !!options[:snapshot]
+    end
+
     # @return [ BSON::Timestamp ] The latest seen operation time for this session.
     #
     # @since 2.5.0
@@ -506,6 +518,10 @@ module Mongo
 =end
       end
 
+      if snapshot?
+        raise Mongo::Error::SnapshotSessionTransactionProhibited
+      end
+
       check_if_ended!
 
       if within_states?(STARTING_TRANSACTION_STATE, TRANSACTION_IN_PROGRESS_STATE)
@@ -1024,6 +1040,9 @@ module Mongo
       @server_session.txn_num
     end
 
+    # @api private
+    attr_accessor :snapshot_timestamp
+
     private
 
     # Get the read concern the session will use when starting a transaction.

data/lib/mongo/socket/ocsp_cache.rb

@@ -21,8 +21,7 @@ module Mongo
     # This module caches OCSP responses for their indicated validity time.
     #
     # The key is the CertificateId used for the OCSP request.
-    # The value is the SingleResponse on Ruby 2.4+, or the OpenStruct
-    # emulation of it on Ruby 2.3.
+    # The value is the SingleResponse.
     #
     # @api private
     module OcspCache
@@ -40,7 +39,7 @@ module Mongo
       # expire by the time caller uses them. The caller should not perform
       # update time checks on the returned response.
       #
-      # @return [ OpenSSL::OCSP::SingleResponse | OpenStruct ] The previously
+      # @return [ OpenSSL::OCSP::SingleResponse ] The previously
       #   retrieved response.
       module_function def get(cert_id)
         resp = responses.detect do |resp|

data/lib/mongo/socket.rb

@@ -362,11 +362,7 @@ module Mongo
     end
 
     def allocate_string(capacity)
-      if RUBY_VERSION >= '2.4.0'
-        String.new('', :capacity => capacity, :encoding => 'BINARY')
-      else
-        ('x'*capacity).force_encoding('BINARY')
-      end
+      String.new('', :capacity => capacity, :encoding => 'BINARY')
     end
 
     def read_buffer_size

data/lib/mongo/utils.rb

@@ -101,11 +101,5 @@ module Mongo
     module_function def monotonic_time
       Process.clock_gettime(Process::CLOCK_MONOTONIC)
     end
-
-    # Hash#compact implementation for Ruby 2.3/2.4
-    # Implementation based on activesupport 5.2.3
-    module_function def slice_hash(hash, *keys)
-      keys.each_with_object({}) { |k, res| res[k] = hash[k] if hash.key?(k) }
-    end
   end
 end

data/lib/mongo/version.rb

@@ -20,5 +20,5 @@ module Mongo
   # The current version of the driver.
   #
   # @since 2.0.0
-  VERSION = '2.16.4'.freeze
+  VERSION = '2.17.0'.freeze
 end

data/mongo.gemspec

@@ -36,7 +36,7 @@ Gem::Specification.new do |s|
   s.require_paths     = ['lib']
   s.bindir            = 'bin'
 
-  s.required_ruby_version = ">= 2.4"
+  s.required_ruby_version = ">= 2.5"
 
   s.add_dependency 'bson', '>=4.8.2', '<5.0.0'
 end

data/spec/integration/query_cache_spec.rb

@@ -345,69 +345,18 @@ describe 'QueryCache' do
 
         it 'uses the cache' do
           results_limit_5 = authorized_collection.find.limit(5).to_a
-          results_limit_negative_5 = authorized_collection.find.limit(-5).to_a
           results_limit_3 = authorized_collection.find.limit(3).to_a
-          results_limit_negative_3 = authorized_collection.find.limit(-3).to_a
           results_no_limit = authorized_collection.find.to_a
-          results_limit_0 = authorized_collection.find.limit(0).to_a
-
-
-          expect(results_limit_5.length).to eq(5)
-          expect(results_limit_5.map { |r| r["test"] }).to eq([0, 1, 2, 3, 4])
-
-          expect(results_limit_negative_5.length).to eq(5)
-          expect(results_limit_negative_5.map { |r| r["test"] }).to eq([0, 1, 2, 3, 4])
-
-          expect(results_limit_3.length).to eq(3)
-          expect(results_limit_3.map { |r| r["test"] }).to eq([0, 1, 2])
-
-          expect(results_limit_negative_3.length).to eq(3)
-          expect(results_limit_negative_3.map { |r| r["test"] }).to eq([0, 1, 2])
-
-          expect(results_no_limit.length).to eq(10)
-          expect(results_no_limit.map { |r| r["test"] }).to eq([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
-
-          expect(results_limit_0.length).to eq(10)
-          expect(results_limit_0.map { |r| r["test"] }).to eq([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
-
-          expect(events.length).to eq(1)
-        end
-      end
-
-      context 'when the first query has a 0 limit' do
-        before do
-          authorized_collection.find.limit(0).to_a
-        end
-
-        it 'uses the cache' do
-          results_limit_5 = authorized_collection.find.limit(5).to_a
-          results_limit_negative_5 = authorized_collection.find.limit(-5).to_a
-          results_limit_3 = authorized_collection.find.limit(3).to_a
-          results_limit_negative_3 = authorized_collection.find.limit(-3).to_a
-          results_no_limit = authorized_collection.find.to_a
-          results_limit_0 = authorized_collection.find.limit(0).to_a
 
           expect(results_limit_5.length).to eq(5)
           expect(results_limit_5.map { |r| r["test"] }).to eq([0, 1, 2, 3, 4])
 
-          expect(results_limit_negative_5.length).to eq(5)
-          expect(results_limit_negative_5.map { |r| r["test"] }).to eq([0, 1, 2, 3, 4])
-
-
           expect(results_limit_3.length).to eq(3)
           expect(results_limit_3.map { |r| r["test"] }).to eq([0, 1, 2])
 
-          expect(results_limit_negative_3.length).to eq(3)
-          expect(results_limit_negative_3.map { |r| r["test"] }).to eq([0, 1, 2])
-
-
           expect(results_no_limit.length).to eq(10)
           expect(results_no_limit.map { |r| r["test"] }).to eq([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
 
-
-          expect(results_limit_0.length).to eq(10)
-          expect(results_limit_0.map { |r| r["test"] }).to eq([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
-
           expect(events.length).to eq(1)
         end
       end
@@ -442,21 +391,6 @@ describe 'QueryCache' do
           end
         end
 
-        context 'and two queries are performed with a larger negative limit' do
-          it 'uses the query cache for the third query' do
-            results1 = authorized_collection.find.limit(-3).to_a
-            results2 = authorized_collection.find.limit(-3).to_a
-
-            expect(results1.length).to eq(3)
-            expect(results1.map { |r| r["test"] }).to eq([0, 1, 2])
-
-            expect(results2.length).to eq(3)
-            expect(results2.map { |r| r["test"] }).to eq([0, 1, 2])
-
-            expect(events.length).to eq(2)
-          end
-        end
-
         context 'and the second query has a smaller limit' do
           let(:results) { authorized_collection.find.limit(1).to_a }
 
@@ -467,99 +401,6 @@ describe 'QueryCache' do
           end
         end
 
-        context 'and the second query has a smaller negative limit' do
-          let(:results) { authorized_collection.find.limit(-1).to_a }
-
-          it 'uses the cached query' do
-            expect(results.count).to eq(1)
-            expect(results.first["test"]).to eq(0)
-            expect(events.length).to eq(1)
-          end
-        end
-
-        context 'and the second query has no limit' do
-          it 'queries again' do
-            expect(authorized_collection.find.to_a.count).to eq(10)
-            expect(events.length).to eq(2)
-          end
-        end
-      end
-
-      context 'when the first query has a negative limit' do
-        before do
-          authorized_collection.find.limit(-2).to_a
-        end
-
-        context 'and the second query has a larger limit' do
-          let(:results) { authorized_collection.find.limit(3).to_a }
-
-          it 'queries again' do
-            expect(results.length).to eq(3)
-            expect(results.map { |result| result["test"] }).to eq([0, 1, 2])
-            expect(events.length).to eq(2)
-          end
-        end
-
-        context 'and the second query has a larger negative limit' do
-          let(:results) { authorized_collection.find.limit(-3).to_a }
-
-          it 'queries again' do
-            expect(results.length).to eq(3)
-            expect(results.map { |result| result["test"] }).to eq([0, 1, 2])
-            expect(events.length).to eq(2)
-          end
-        end
-
-        context 'and two queries are performed with a larger limit' do
-          it 'uses the query cache for the third query' do
-            results1 = authorized_collection.find.limit(3).to_a
-            results2 = authorized_collection.find.limit(3).to_a
-
-            expect(results1.length).to eq(3)
-            expect(results1.map { |r| r["test"] }).to eq([0, 1, 2])
-
-            expect(results2.length).to eq(3)
-            expect(results2.map { |r| r["test"] }).to eq([0, 1, 2])
-
-            expect(events.length).to eq(2)
-          end
-        end
-
-        context 'and two queries are performed with a larger negative limit' do
-          it 'uses the query cache for the third query' do
-            results1 = authorized_collection.find.limit(-3).to_a
-            results2 = authorized_collection.find.limit(-3).to_a
-
-            expect(results1.length).to eq(3)
-            expect(results1.map { |r| r["test"] }).to eq([0, 1, 2])
-
-            expect(results2.length).to eq(3)
-            expect(results2.map { |r| r["test"] }).to eq([0, 1, 2])
-
-            expect(events.length).to eq(2)
-          end
-        end
-
-        context 'and the second query has a smaller limit' do
-          let(:results) { authorized_collection.find.limit(1).to_a }
-
-          it 'uses the cached query' do
-            expect(results.count).to eq(1)
-            expect(results.first["test"]).to eq(0)
-            expect(events.length).to eq(1)
-          end
-        end
-
-        context 'and the second query has a smaller negative limit' do
-          let(:results) { authorized_collection.find.limit(-1).to_a }
-
-          it 'uses the cached query' do
-            expect(results.count).to eq(1)
-            expect(results.first["test"]).to eq(0)
-            expect(events.length).to eq(1)
-          end
-        end
-
         context 'and the second query has no limit' do
           it 'queries again' do
             expect(authorized_collection.find.to_a.count).to eq(10)