mongo 2.16.2 → 2.17.0

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/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_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.2'.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/read_preference_spec.rb

@@ -45,16 +45,6 @@ describe 'Read preference' do
     {}
   end
 
-  shared_examples_for 'sends expected read preference when reading' do
-    it 'sends expected read preference when reading' do
-      read_operation
-
-      event = subscriber.single_command_started_event('find')
-      actual_preference = event.command['$readPreference']
-      expect(actual_preference).to eq(expected_read_preference)
-    end
-  end
-
   shared_examples_for 'does not send read preference when reading' do
     it 'does not send read preference when reading' do
       read_operation
@@ -95,7 +85,17 @@ describe 'Read preference' do
       context 'server supporting OP_MSG' do
         min_server_fcv '3.6'
 
-        it_behaves_like 'sends expected read preference when reading'
+        it 'sends expected read preference when reading' do
+          read_operation
+
+          event = subscriber.single_command_started_event('find')
+          actual_preference = event.command['$readPreference']
+          if expected_read_preference&.[]("mode") == "primary"
+            expect(actual_preference).to be_nil
+          else
+            expect(actual_preference).to eq(expected_read_preference)
+          end
+        end
       end
     end
 
@@ -307,7 +307,11 @@ describe 'Read preference' do
 
           event = subscriber.single_command_started_event('find')
           actual_preference = event.command['$readPreference']
-          expect(actual_preference).to eq(expected_read_preference)
+          if expected_read_preference&.[]("mode") == "primary"
+            expect(actual_preference).to be_nil
+          else
+            expect(actual_preference).to eq(expected_read_preference)
+          end
         end
       end
     end

data/spec/lite_spec_helper.rb

@@ -157,13 +157,6 @@ RSpec.configure do |config|
 end
 
 if SpecConfig.instance.active_support?
-  require "active_support/version"
-  if ActiveSupport.version >= Gem::Version.new(7)
-    # ActiveSupport wants us to require ALL of it all of the time.
-    # See: https://github.com/rails/rails/issues/43851,
-    # https://github.com/rails/rails/issues/43889, etc.
-    require 'active_support'
-  end
   require "active_support/time"
   require 'mongo/active_support'
 end

data/spec/mongo/collection/view/aggregation_spec.rb

@@ -29,8 +29,16 @@ describe Mongo::Collection::View::Aggregation do
     described_class.new(view, pipeline, options)
   end
 
+  let(:server) do
+    double('server')
+  end
+
+  let(:session) do
+    double('session')
+  end
+
   let(:aggregation_spec) do
-    aggregation.send(:aggregate_spec, double('session'))
+    aggregation.send(:aggregate_spec, server, session, nil)
   end
 
   before do
@@ -351,15 +359,15 @@ describe Mongo::Collection::View::Aggregation do
 
   describe '#aggregate_spec' do
 
-    context 'when the collection has a read preference' do
+    context 'when a read preference is given' do
 
       let(:read_preference) do
-        {mode: :secondary}
+        BSON::Document.new({mode: :secondary})
       end
 
       it 'includes the read preference in the spec' do
-        allow(authorized_collection).to receive(:read_preference).and_return(read_preference)
-        expect(aggregation_spec[:read]).to eq(read_preference)
+        spec = aggregation.send(:aggregate_spec, server, session, read_preference)
+        expect(spec[:read]).to eq(read_preference)
       end
     end
 
@@ -570,109 +578,77 @@ describe Mongo::Collection::View::Aggregation do
   end
 
   context 'when $out is in the pipeline' do
-
-    let(:pipeline) do
-      [{
-           "$group" => {
-               "_id" => "$city",
-               "totalpop" => { "$sum" => "$pop" }
+    [['$out', 'string'], [:$out, 'symbol']].each do |op, type|
+      context "when #{op} is a #{type}" do
+        let(:pipeline) do
+          [{
+               "$group" => {
+                   "_id" => "$city",
+                   "totalpop" => { "$sum" => "$pop" }
+               }
+           },
+           {
+               op => 'output_collection'
            }
-       },
-       {
-           '$out' => 'output_collection'
-       }
-      ]
-    end
-
-    before do
-      authorized_client['output_collection'].delete_many
-    end
-
-    context 'when $out is a string' do
-
-      it 'does not allow the operation on a secondary' do
-        expect(aggregation.send(:secondary_ok?)).to be(false)
-      end
-    end
-
-    context 'when $out is a symbol' do
-
-      let(:pipeline) do
-        [{
-             "$group" => {
-                 "_id" => "$city",
-                 "totalpop" => { "$sum" => "$pop" }
-             }
-         },
-         {
-             :$out => 'output_collection'
-         }
-        ]
-      end
-
-      it 'does not allow the operation on a secondary' do
-        expect(aggregation.send(:secondary_ok?)).to be(false)
-      end
-    end
+          ]
+        end
 
+        before do
+          authorized_client['output_collection'].delete_many
+        end
 
-    context 'when the server is not a valid for writing' do
+        let(:features) do
+          double()
+        end
 
-     it 'reroutes the operation to a primary' do
-       allow(aggregation).to receive(:valid_server?).and_return(false)
-       expect(Mongo::Logger.logger).to receive(:warn).and_call_original
-       aggregation.to_a
-     end
-    end
+        let(:server) do
+          double().tap do |server|
+            allow(server).to receive(:features).and_return(features)
+          end
+        end
 
-    context 'when the server is a valid for writing' do
+        context 'when the view has a write concern' do
 
-     it 'does not reroute the operation to a primary' do
-       expect(Mongo::Logger.logger).not_to receive(:warn)
-       aggregation.to_a
-     end
+          let(:collection) do
+            authorized_collection.with(write: INVALID_WRITE_CONCERN)
+          end
 
-     context 'when the view has a write concern' do
+          let(:view) do
+            Mongo::Collection::View.new(collection, selector, view_options)
+          end
 
-       let(:collection) do
-         authorized_collection.with(write: INVALID_WRITE_CONCERN)
-       end
+          context 'when the server supports write concern on the aggregate command' do
+            min_server_fcv '3.4'
 
-       let(:view) do
-         Mongo::Collection::View.new(collection, selector, view_options)
-       end
+            it 'uses the write concern' do
+              expect {
+                aggregation.to_a
+              }.to raise_exception(Mongo::Error::OperationFailure)
+            end
+          end
 
-       context 'when the server supports write concern on the aggregate command' do
-        min_server_fcv '3.4'
+          context 'when the server does not support write concern on the aggregation command' do
+            max_server_version '3.2'
 
-         it 'uses the write concern' do
-           expect {
-             aggregation.to_a
-           }.to raise_exception(Mongo::Error::OperationFailure)
-         end
-       end
+            let(:documents) do
+              [
+                { city: "Berlin", pop: 18913, neighborhood: "Kreuzberg" },
+                { city: "Berlin", pop: 84143, neighborhood: "Mitte" },
+                { city: "New York", pop: 40270, neighborhood: "Brooklyn" }
+              ]
+            end
 
-       context 'when the server does not support write concern on the aggregation command' do
-        max_server_version '3.2'
+            before do
+              authorized_collection.insert_many(documents)
+              aggregation.to_a
+            end
 
-         let(:documents) do
-           [
-             { city: "Berlin", pop: 18913, neighborhood: "Kreuzberg" },
-             { city: "Berlin", pop: 84143, neighborhood: "Mitte" },
-             { city: "New York", pop: 40270, neighborhood: "Brooklyn" }
-           ]
-         end
-
-         before do
-           authorized_collection.insert_many(documents)
-           aggregation.to_a
-         end
-
-         it 'does not apply the write concern' do
-           expect(authorized_client['output_collection'].find.count).to eq(2)
-         end
-       end
-     end
+            it 'does not apply the write concern' do
+              expect(authorized_client['output_collection'].find.count).to eq(2)
+            end
+          end
+        end
+      end
     end
   end
 end

data/spec/mongo/collection/view/change_stream_spec.rb

@@ -56,7 +56,7 @@ describe Mongo::Collection::View::ChangeStream do
 
   let(:command_spec) do
     change_stream.send(:instance_variable_set, '@resuming', false)
-    change_stream.send(:aggregate_spec, double('session'))
+    change_stream.send(:aggregate_spec, double('server'), double('session'), nil)
   end
 
   let(:cursor) do

data/spec/mongo/collection/view/map_reduce_spec.rb

@@ -60,6 +60,14 @@ describe Mongo::Collection::View::MapReduce do
     described_class.new(view, map, reduce, options)
   end
 
+  describe '#initialize' do
+    it 'warns of deprecation' do
+      Mongo::Logger.logger.should receive(:warn).with('MONGODB | The map_reduce operation is deprecated, please use the aggregation pipeline instead')
+
+      map_reduce
+    end
+  end
+
   describe '#map_function' do
 
     it 'returns the map function' do
@@ -672,7 +680,12 @@ describe Mongo::Collection::View::MapReduce do
         end
 
         it 'does not reroute the operation to a primary' do
-          expect(Mongo::Logger.logger).not_to receive(:warn)
+          # We produce a deprecation warning, but there shouldn't be
+          # the reroute warning.
+          expect(Mongo::Logger.logger).to receive(:warn).once do |msg|
+            expect(msg).not_to include('Rerouting the MapReduce operation to the primary server')
+          end
+
           map_reduce.to_a
         end
       end
@@ -865,20 +878,4 @@ describe Mongo::Collection::View::MapReduce do
       end
     end
   end
-
-  describe '#map_reduce_spec' do
-    context 'when read preference is given' do
-      let(:view_options) do
-        { read: {mode: :secondary} }
-      end
-
-      context 'selector' do
-        # For compatibility with released versions of Mongoid, this method
-        # must return read preference under the :read key.
-        it 'contains read preference' do
-          map_reduce_spec[:selector][:read].should == {'mode' => :secondary}
-        end
-      end
-    end
-  end
 end