mongo 2.9.2 → 2.10.0.rc0

data/lib/mongo/uri/srv_protocol.rb

@@ -103,7 +103,10 @@ module Mongo
 
         records = get_records(hostname)
         @txt_options = get_txt_opts(hostname) || {}
-        @servers = parse_servers!(records.join(','))
+        records.each do |record|
+          validate_host!(record)
+        end
+        @servers = records
       end
 
       # Validates the hostname used in an SRV URI.

data/lib/mongo/version.rb

@@ -17,5 +17,5 @@ module Mongo
   # The current version of the driver.
   #
   # @since 2.0.0
-  VERSION = '2.9.2'.freeze
+  VERSION = '2.10.0.rc0'.freeze
 end

data/lib/mongo/write_concern.rb

@@ -27,26 +27,31 @@ module Mongo
     # The number of servers write concern.
     #
     # @since 2.0.0
+    # @deprecated
     W = :w.freeze
 
     # The journal write concern.
     #
     # @since 2.0.0
+    # @deprecated
     J = :j.freeze
 
     # The file sync write concern.
     #
     # @since 2.0.0
+    # @deprecated
     FSYNC = :fsync.freeze
 
     # The wtimeout write concern.
     #
     # @since 2.0.0
+    # @deprecated
     WTIMEOUT = :wtimeout.freeze
 
     # The GLE command name.
     #
     # @since 2.0.0
+    # @deprecated
     GET_LAST_ERROR = :getlasterror.freeze
 
     # The default write concern is to acknowledge on a single server.
@@ -56,6 +61,8 @@ module Mongo
 
     # Create a write concern object for the provided options.
     #
+    # If options are nil, returns nil.
+    #
     # @example Get a write concern.
     #   Mongo::WriteConcern.get(:w => 1)
     #
@@ -70,46 +77,20 @@ module Mongo
     # @option options :wtimeout [ Integer ] The number of milliseconds to
     #   wait for acknowledgement before raising an error.
     #
-    # @return [ Unacknowledged, Acknowledged ] The appropriate concern.
+    # @return [ nil | Unacknowledged | Acknowledged ] The appropriate concern.
     #
     # @raise [ Error::InvalidWriteConcern ] If the options are invalid.
     #
     # @since 2.0.0
     def get(options)
-      return options if options.is_a?(Unacknowledged) || options.is_a?(Acknowledged)
+      return options if options.is_a?(Base)
       if options
-        validate!(options)
-        if unacknowledged?(options)
+        if (options[:w] || options['w']) == 0
           Unacknowledged.new(options)
         else
           Acknowledged.new(options)
         end
       end
     end
-
-    private
-
-    def validate!(options)
-      if options[W]
-        if options[W] == 0 && (options[J] || options[FSYNC])
-          raise Mongo::Error::InvalidWriteConcern.new
-        elsif options[W].is_a?(Integer) && options[W] < 0
-          raise Mongo::Error::InvalidWriteConcern.new
-        end
-      end
-    end
-
-    # Determine if the options are for an unacknowledged write concern.
-    #
-    # @api private
-    #
-    # @param [ Hash ] options The options to check.
-    #
-    # @return [ true, false ] If the options are unacknowledged.
-    #
-    # @since 2.0.0
-    def unacknowledged?(options)
-      options[W] == 0
-    end
   end
 end

data/lib/mongo/write_concern/acknowledged.rb

@@ -34,6 +34,18 @@ module Mongo
         )
       end
 
+      # Is this write concern acknowledged.
+      #
+      # @example Whether this write concern object is acknowledged.
+      #   write_concern.acknowledged?
+      #
+      # @return [ true, false ] Whether this write concern is acknowledged.
+      #
+      # @since 2.5.0
+      def acknowledged?
+        true
+      end
+
       # Get a human-readable string representation of an acknowledged write concern.
       #
       # @example Inspect the write concern.

data/lib/mongo/write_concern/base.rb

@@ -43,20 +43,24 @@ module Mongo
       #
       # @since 2.0.0
       def initialize(options)
-        opts =  Options::Mapper.transform_keys_to_symbols(options)
-        @options = Options::Mapper.transform_values_to_strings(opts).freeze
-      end
+        options = Options::Mapper.transform_keys_to_symbols(options)
+        options = Options::Mapper.transform_values_to_strings(options).freeze
 
-      # Is this write concern acknowledged.
-      #
-      # @example Whether this write concern object is acknowledged.
-      #   write_concern.acknowledged?
-      #
-      # @return [ true, false ] Whether this write concern is acknowledged.
-      #
-      # @since 2.5.0
-      def acknowledged?
-        !!get_last_error
+        if options[:w]
+          if options[:w] == 0 && options[:j]
+            raise Error::InvalidWriteConcern, "Invalid write concern options: :j cannot be true when :w is 0: #{options.inspect}"
+          elsif options[:w] == 0 && options[:fsync]
+            raise Error::InvalidWriteConcern, "Invalid write concern options: :fsync cannot be true when :w is 0: #{options.inspect}"
+          elsif options[:w].is_a?(Integer) && options[:w] < 0
+            raise Error::InvalidWriteConcern, "Invalid write concern options: :w cannot be negative (#{options[:w]}): #{options.inspect}"
+          end
+        end
+
+        if options[:journal]
+          raise Error::InvalidWriteConcern, "Invalid write concern options: use :j for journal: #{options.inspect}"
+        end
+
+        @options = options
       end
     end
   end

data/lib/mongo/write_concern/unacknowledged.rb

@@ -37,6 +37,18 @@ module Mongo
         NOOP
       end
 
+      # Is this write concern acknowledged.
+      #
+      # @example Whether this write concern object is acknowledged.
+      #   write_concern.acknowledged?
+      #
+      # @return [ true, false ] Whether this write concern is acknowledged.
+      #
+      # @since 2.5.0
+      def acknowledged?
+        false
+      end
+
       # Get a human-readable string representation of an unacknowledged write concern.
       #
       # @example Inspect the write concern.

data/spec/atlas/atlas_connectivity_spec.rb

@@ -1,16 +1,16 @@
 require 'lite_spec_helper'
 
 describe 'Atlas connectivity' do
-  shared_examples 'connects to Atlas' do
-    let(:uri) { ENV[var] }
-    let(:client) { Mongo::Client.new(uri) }
+  let(:uri) { ENV['ATLAS_URI'] }
+  let(:client) { Mongo::Client.new(uri) }
 
-    before do
-      if uri.nil?
-        skip "#{var} not set in environment"
-      end
+  before do
+    if uri.nil?
+      skip "ATLAS_URI not set in environment"
     end
+  end
 
+  describe 'connection to Atlas' do
     it 'runs ismaster successfully' do
       result = client.database.command(:ismaster => 1)
       expect(result.documents.first['ismaster']).to be true
@@ -21,34 +21,4 @@ describe 'Atlas connectivity' do
       expect(result).to be_a(Array)
     end
   end
-
-  context 'Atlas replica set' do
-    let(:var) { 'ATLAS_REPLICA_SET_URI' }
-
-    it_behaves_like 'connects to Atlas'
-  end
-
-  context 'Atlas sharded cluster' do
-    let(:var) { 'ATLAS_SHARDED_URI' }
-
-    it_behaves_like 'connects to Atlas'
-  end
-
-  context 'Atlas free tier replica set' do
-    let(:var) { 'ATLAS_FREE_TIER_URI' }
-
-    it_behaves_like 'connects to Atlas'
-  end
-
-  context 'Atlas TLS 1.1 only replica set' do
-    let(:var) { 'ATLAS_TLS11_URI' }
-
-    it_behaves_like 'connects to Atlas'
-  end
-
-  context 'Atlas TLS 1.2 only replica set' do
-    let(:var) { 'ATLAS_TLS12_URI' }
-
-    it_behaves_like 'connects to Atlas'
-  end
 end

data/spec/atlas/operations_spec.rb

@@ -0,0 +1,25 @@
+require 'lite_spec_helper'
+
+describe 'Operations' do
+  let(:uri) { ENV['ATLAS_URI'] }
+  let(:client) { Mongo::Client.new(uri) }
+
+  before do
+    if uri.nil?
+      skip "ATLAS_URI not set in environment"
+    end
+  end
+
+  describe 'list_collections' do
+    # Atlas free tier proxy enforces restrictions on list_collections
+    # arguments. This tests verifies that list_collections works on Atlas
+
+    it 'works' do
+      # We are not allowed to mutate the database, therefore the list of
+      # collections would generally be empty.
+      expect do
+        client.database.list_collections
+      end.not_to raise_error
+    end
+  end
+end

data/spec/integration/change_stream_examples_spec.rb

@@ -3,6 +3,12 @@ require 'spec_helper'
 describe 'change streams examples in Ruby' do
   min_server_fcv '3.6'
   require_topology :replica_set
+  require_wired_tiger
+
+  # On JRuby, change streams should be accessed using try_next on the
+  # change stream objects rather than using the Enumerable interface.
+  # https://jira.mongodb.org/browse/RUBY-1877
+  fails_on_jruby
 
   let!(:inventory) do
     client[:inventory]
@@ -17,7 +23,7 @@ describe 'change streams examples in Ruby' do
   end
 
   after do
-    client.close
+    client.close(true)
   end
 
   context 'example 1 - basic watching'do
@@ -103,10 +109,30 @@ describe 'change streams examples in Ruby' do
 
     it 'returns the correct change when resuming' do
 
-      stream = inventory.watch
-      cursor = stream.to_enum
-      inventory.insert_one(x: 1)
-      next_change = cursor.next
+      insert_thread = Thread.new do
+        sleep 2
+        inventory.insert_one(x: 1)
+        inventory.insert_one(x: 2)
+      end
+
+      next_change = nil
+      resume_stream_thread = Thread.new do
+
+        # Start Changestream Example 3
+
+        change_stream = inventory.watch
+        cursor = change_stream.to_enum
+        next_change = cursor.next
+        resume_token = change_stream.resume_token
+
+        new_cursor = inventory.watch([], resume_after: resume_token).to_enum
+        resumed_change = new_cursor.next
+
+        # End Changestream Example 3
+      end
+
+      insert_thread.value
+      resumed_change = resume_stream_thread.value
 
       expect(next_change['_id']).not_to be_nil
       expect(next_change['_id']['_data']).not_to be_nil
@@ -120,32 +146,20 @@ describe 'change streams examples in Ruby' do
       expect(next_change['documentKey']).not_to be_nil
       expect(next_change['documentKey']['_id']).to eq(next_change['fullDocument']['_id'])
 
-      inventory.insert_one(x: 2)
-      next_next_change = cursor.next
-      stream.close
-
-      expect(next_next_change['_id']).not_to be_nil
-      expect(next_next_change['_id']['_data']).not_to be_nil
-      expect(next_next_change['operationType']).to eq('insert')
-      expect(next_next_change['fullDocument']).not_to be_nil
-      expect(next_next_change['fullDocument']['_id']).not_to be_nil
-      expect(next_next_change['fullDocument']['x']).to eq(2)
-      expect(next_next_change['ns']).not_to be_nil
-      expect(next_next_change['ns']['db']).to eq(SpecConfig.instance.test_db)
-      expect(next_next_change['ns']['coll']).to eq(inventory.name)
-      expect(next_next_change['documentKey']).not_to be_nil
-      expect(next_next_change['documentKey']['_id']).to eq(next_next_change['fullDocument']['_id'])
-
-      # Start Changestream Example 3
-
-      resume_token = next_change['_id']
-      cursor = inventory.watch([], resume_after: resume_token).to_enum
-      resumed_change = cursor.next
-
-      # End Changestream Example 3
-
-      expect(resumed_change.length).to eq(next_next_change.length)
-      resumed_change.each { |key| expect(resumed_change[key]).to eq(next_next_change[key]) }
+      expect(resumed_change['_id']).not_to be_nil
+      expect(resumed_change['_id']['_data']).not_to be_nil
+      expect(resumed_change['operationType']).to eq('insert')
+      expect(resumed_change['fullDocument']).not_to be_nil
+      expect(resumed_change['fullDocument']['_id']).not_to be_nil
+      expect(resumed_change['fullDocument']['x']).to eq(2)
+      expect(resumed_change['ns']).not_to be_nil
+      expect(resumed_change['ns']['db']).to eq(SpecConfig.instance.test_db)
+      expect(resumed_change['ns']['coll']).to eq(inventory.name)
+      expect(resumed_change['documentKey']).not_to be_nil
+      expect(resumed_change['documentKey']['_id']).to eq(resumed_change['fullDocument']['_id'])
+
+      expect(resumed_change.length).to eq(resumed_change.length)
+      resumed_change.each { |key| expect(resumed_change[key]).to eq(resumed_change[key]) }
     end
   end
 

data/spec/integration/change_stream_spec.rb

@@ -5,6 +5,7 @@ describe 'Change stream integration', retry: 4 do
   max_example_run_time 7
   min_server_fcv '3.6'
   require_topology :replica_set
+  require_wired_tiger
 
   let(:fail_point_base_command) do
     { 'configureFailPoint' => "failCommand" }
@@ -45,6 +46,25 @@ describe 'Change stream integration', retry: 4 do
       end
     end
 
+    shared_examples_for 'raises an exception' do
+      it 'raises an exception and does not attempt to resume' do
+        change_stream
+
+        subscriber = EventSubscriber.new
+        authorized_client.subscribe(Mongo::Monitoring::COMMAND, subscriber)
+
+        expect do
+          change_stream.to_enum.next
+        end.to raise_error(Mongo::Error::OperationFailure)
+
+        aggregate_commands = subscriber.started_events.select { |e| e.command_name == 'aggregate' }
+        expect(aggregate_commands.length).to be 0
+
+        get_more_commands = subscriber.started_events.select { |e| e.command_name == 'getMore' }
+        expect(get_more_commands.length).to be 1
+      end
+    end
+
     context 'no errors' do
       it 'next returns changes' do
         change_stream
@@ -86,10 +106,36 @@ describe 'Change stream integration', retry: 4 do
         before do
           authorized_collection.client.use(:admin).command(fail_point_base_command.merge(
             :mode => {:times => 1},
-            :data => {:failCommands => ['getMore'], errorCode: 100}))
+            :data => {:failCommands => ['getMore'], errorCode: errorCode}))
         end
 
-        it_behaves_like 'returns a change document'
+        context 'when the error is resumable' do
+          let(:errorCode) do
+            100
+          end
+          it_behaves_like 'returns a change document'
+        end
+
+        context 'when the error is Interrupted' do
+          let(:errorCode) do
+            11601
+          end
+          it_behaves_like 'raises an exception'
+        end
+
+        context 'when the error is CappedPositionLost' do
+          let(:errorCode) do
+            136
+          end
+          it_behaves_like 'raises an exception'
+        end
+
+        context 'when the error is CursorKilled' do
+          let(:errorCode) do
+            237
+          end
+          it_behaves_like 'raises an exception'
+        end
       end
 
       context 'error on a getMore other than first' do
@@ -105,10 +151,36 @@ describe 'Change stream integration', retry: 4 do
 
           authorized_collection.client.use(:admin).command(fail_point_base_command.merge(
             :mode => {:times => 1},
-            :data => {:failCommands => ['getMore'], errorCode: 100}))
+            :data => {:failCommands => ['getMore'], errorCode: errorCode}))
         end
 
-        it_behaves_like 'returns a change document'
+        context 'when the error is resumable' do
+          let(:errorCode) do
+            100
+          end
+          it_behaves_like 'returns a change document'
+        end
+
+        context 'when the error is Interrupted' do
+          let(:errorCode) do
+            11601
+          end
+          it_behaves_like 'raises an exception'
+        end
+
+        context 'when the error is CappedPositionLost' do
+          let(:errorCode) do
+            136
+          end
+          it_behaves_like 'raises an exception'
+        end
+
+        context 'when the error is CursorKilled' do
+          let(:errorCode) do
+            237
+          end
+          it_behaves_like 'raises an exception'
+        end
       end
     end
 
@@ -369,7 +441,7 @@ describe 'Change stream integration', retry: 4 do
 
   describe ':start_after option' do
     require_topology :replica_set
-    min_server_version '4.1'
+    min_server_fcv '4.2'
 
     let(:start_after) do
       stream = authorized_collection.watch([])
@@ -430,4 +502,232 @@ describe 'Change stream integration', retry: 4 do
       end
     end
   end
+
+  describe 'resume_token' do
+    let(:stream) { authorized_collection.watch }
+
+    let(:events) do
+      subscriber = EventSubscriber.new
+      authorized_client.subscribe(Mongo::Monitoring::COMMAND, subscriber)
+      use_stream
+      subscriber.succeeded_events.select { |e|
+        e.command_name == 'aggregate' || e.command_name === 'getMore'
+      }
+    end
+
+    let!(:sample_resume_token) do
+      cs = authorized_collection.watch
+      authorized_collection.insert_one(a: 1)
+      doc = cs.to_enum.next
+      cs.close
+      doc[:_id]
+    end
+
+    let(:use_stream) do
+      stream
+      authorized_collection.insert_one(x: 1)
+      stream.to_enum.next
+    end
+
+    context 'when batch has been emptied' do
+      context '4.2+' do
+        min_server_fcv '4.2'
+        it 'returns post batch resume token from current command response' do
+          expect(events.size).to eq(2)
+
+          aggregate_response = events.first.reply
+          get_more_response = events.last.reply
+          expect(aggregate_response['cursor'].key?('postBatchResumeToken')).to eq(true)
+          expect(get_more_response['cursor'].key?('postBatchResumeToken')).to eq(true)
+
+          res_tok = stream.resume_token
+          expect(res_tok).to eq(get_more_response['cursor']['postBatchResumeToken'])
+          expect(res_tok).to_not eq(aggregate_response['cursor']['postBatchResumeToken'])
+        end
+      end
+
+      context '4.0-' do
+        max_server_version '4.0'
+
+        it 'returns _id of previous document returned if one exists' do
+          doc = use_stream
+          expect(stream.resume_token).to eq(doc['_id'])
+        end
+
+        context 'when start_after is specified' do
+          min_server_fcv '4.2'
+
+          it 'must return startAfter from the initial aggregate if the option was specified' do
+            start_after = sample_resume_token
+            authorized_collection.insert_one(:a => 1)
+            stream = authorized_collection.watch([], { start_after: start_after })
+
+            expect(stream.resume_token).to eq(start_after)
+          end
+        end
+
+        it 'must return resumeAfter from the initial aggregate if the option was specified' do
+          resume_after = sample_resume_token
+          authorized_collection.insert_one(:a => 1)
+          stream = authorized_collection.watch([], { resume_after: resume_after })
+
+          expect(stream.resume_token).to eq(resume_after)
+        end
+
+        it 'must be empty if neither the startAfter nor resumeAfter options were specified' do
+          authorized_collection.insert_one(:a => 1)
+          stream = authorized_collection.watch
+
+          expect(stream.resume_token).to be(nil)
+        end
+      end
+    end
+
+    context 'before batch has been emptied' do
+      it 'returns _id of previous document returned' do
+        stream
+
+        authorized_collection.insert_one(:a => 1)
+        authorized_collection.insert_one(:a => 1)
+        authorized_collection.insert_one(:a => 1)
+        stream.to_enum.next
+
+        change = stream.to_enum.next
+
+        expect(stream.resume_token).to eq(change['_id'])
+      end
+    end
+
+    # Note that the watch method executes the initial aggregate command
+    context 'for non-empty, non-iterated batch, only the initial aggregate command executed' do
+
+      let (:use_stream) do
+        authorized_collection.insert_one(:a => 1)
+        stream
+      end
+
+      context 'if startAfter was specified' do
+        min_server_fcv '4.2'
+
+        let (:stream) do
+          authorized_collection.watch([], { start_after: sample_resume_token })
+        end
+
+        it 'must return startAfter from the initial aggregate' do
+          # Need to sample a doc id from the stream before we use the stream, so
+          # the events subscriber does not record these commands as part of the example.
+          sample_resume_token
+
+          # Verify that only the initial aggregate command was executed
+          expect(events.size).to eq(1)
+          expect(events.first.command_name).to eq('aggregate')
+          expect(stream.resume_token).to eq(sample_resume_token)
+        end
+      end
+
+      context 'if resumeAfter was specified' do
+        let (:stream) do
+          authorized_collection.watch([], { resume_after: sample_resume_token })
+        end
+
+        it 'must return resumeAfter from the initial aggregate' do
+          sample_resume_token
+
+          expect(events.size).to eq(1)
+          expect(events.first.command_name).to eq('aggregate')
+          expect(stream.resume_token).to eq(sample_resume_token)
+        end
+      end
+
+      context 'if neither the startAfter nor resumeAfter options were specified' do
+        it 'must be empty' do
+          expect(events.size).to eq(1)
+          expect(events.first.command_name).to eq('aggregate')
+          expect(stream.resume_token).to be(nil)
+        end
+      end
+    end
+
+
+    context 'for non-empty, non-iterated batch directly after get_more' do
+      let(:next_doc) do
+        authorized_collection.insert_one(:a => 1)
+        stream.to_enum.next
+      end
+
+      let(:do_get_more) do
+        authorized_collection.insert_one(:a => 1)
+        stream.instance_variable_get('@cursor').get_more
+      end
+
+      context '4.2+' do
+        min_server_fcv '4.2'
+
+        let(:use_stream) do
+          stream
+          next_doc
+          do_get_more
+        end
+
+        it 'returns post batch resume token from previous command response' do
+          expect(events.size).to eq(3)
+
+          expect(events.last.command_name).to eq('getMore')
+
+          first_get_more = events[1].reply
+          second_get_more = events[2].reply
+          expect(first_get_more['cursor'].key?('postBatchResumeToken')).to eq(true)
+          expect(second_get_more['cursor'].key?('postBatchResumeToken')).to eq(true)
+
+          res_tok = stream.resume_token
+          expect(res_tok).to eq(first_get_more['cursor']['postBatchResumeToken'])
+          expect(res_tok).not_to eq(second_get_more['cursor']['postBatchResumeToken'])
+        end
+      end
+
+      context '4.0-' do
+        max_server_version '4.0'
+
+        context 'if a document was returned' do
+          let(:use_stream) do
+            stream
+            next_doc
+            do_get_more
+          end
+
+          it 'returns _id of previous document' do
+            expect(events.last.command_name).to eq('getMore')
+            expect(stream.resume_token).to eq(next_doc['_id'])
+          end
+        end
+
+        context 'if a document was not returned' do
+          let(:use_stream) do
+            stream
+            do_get_more
+          end
+
+          context 'when resumeAfter is specified' do
+            let (:stream) do
+              authorized_collection.watch([], { resume_after: sample_resume_token })
+            end
+
+            it 'must return resumeAfter from the initial aggregate if the option was specified' do
+              sample_resume_token
+
+              expect(events.last.command_name).to eq('getMore')
+              expect(stream.resume_token).to eq(sample_resume_token)
+            end
+          end
+
+          context 'if neither the startAfter nor resumeAfter options were specified' do
+            it 'must be empty' do
+              expect(events.last.command_name).to eq('getMore')
+              expect(stream.resume_token).to be(nil)
+            end
+          end
+        end
+      end
+    end
+  end
 end