mongo 2.15.0 → 2.17.0

data/spec/mongo/client_construction_spec.rb

@@ -6,7 +6,7 @@ require 'spec_helper'
 describe Mongo::Client do
   clean_slate
 
-  let(:subscriber) { EventSubscriber.new }
+  let(:subscriber) { Mrss::EventSubscriber.new }
 
   describe '.new' do
     context 'with scan: false' do
@@ -24,26 +24,8 @@ describe Mongo::Client do
     end
 
     context 'with default scan: true' do
-      # TODO this test requires there being no outstanding background
-      # monitoring threads running, as otherwise the scan! expectation
-      # can be executed on a thread that belongs to one of the global
-      # clients for instance
-      it 'performs one round of sdam' do
-        # Does not work due to
-        # https://github.com/rspec/rspec-mocks/issues/1242.
-        #expect_any_instance_of(Mongo::Server::Monitor).to receive(:scan!).
-        #  exactly(SpecConfig.instance.addresses.length).times.and_call_original
-        c = new_local_client(
-          SpecConfig.instance.addresses, SpecConfig.instance.test_options)
-        expect(c.cluster.servers).not_to be_empty
-      end
-
-      # This checks the case of all initial seeds being removed from
-      # cluster during SDAM
-      context 'me mismatch on the only initial seed' do
-        let(:address) do
-          ClusterConfig.instance.alternate_address.to_s
-        end
+
+      shared_examples 'does not wait for server selection timeout' do
 
         let(:logger) do
           Logger.new(STDOUT, level: Logger::DEBUG)
@@ -94,6 +76,7 @@ describe Mongo::Client do
             Mongo::Cluster::Topology::ReplicaSetWithPrimary,
             Mongo::Cluster::Topology::Single,
             Mongo::Cluster::Topology::Sharded,
+            Mongo::Cluster::Topology::LoadBalanced,
           ]).to include(actual_class)
           expect(time_taken).to be < 5
 
@@ -101,6 +84,44 @@ describe Mongo::Client do
           client.database.command(ping: 1)
         end
       end
+
+      context 'when cluster is monitored' do
+        require_topology :single, :replica_set, :sharded
+
+        # TODO this test requires there being no outstanding background
+        # monitoring threads running, as otherwise the scan! expectation
+        # can be executed on a thread that belongs to one of the global
+        # clients for instance
+        it 'performs one round of sdam' do
+          # Does not work due to
+          # https://github.com/rspec/rspec-mocks/issues/1242.
+          #expect_any_instance_of(Mongo::Server::Monitor).to receive(:scan!).
+          #  exactly(SpecConfig.instance.addresses.length).times.and_call_original
+          c = new_local_client(
+            SpecConfig.instance.addresses, SpecConfig.instance.test_options)
+          expect(c.cluster.servers).not_to be_empty
+        end
+
+        # This checks the case of all initial seeds being removed from
+        # cluster during SDAM
+        context 'me mismatch on the only initial seed' do
+          let(:address) do
+            ClusterConfig.instance.alternate_address.to_s
+          end
+
+          include_examples 'does not wait for server selection timeout'
+        end
+      end
+
+      context 'when cluster is not monitored' do
+        require_topology :load_balanced
+
+        let(:address) do
+          ClusterConfig.instance.alternate_address.to_s
+        end
+
+        include_examples 'does not wait for server selection timeout'
+      end
     end
 
     context 'with monitoring_io: false' do
@@ -388,10 +409,24 @@ describe Mongo::Client do
             end.should_not raise_error
           end
 
-          it 'fails server selection due to very small timeout' do
-            lambda do
-              client.database.command(ping: 1)
-            end.should raise_error(Mongo::Error::NoServerAvailable)
+          context 'non-lb' do
+            require_topology :single, :replica_set, :sharded
+
+            it 'fails server selection due to very small timeout' do
+              lambda do
+                client.database.command(ping: 1)
+              end.should raise_error(Mongo::Error::NoServerAvailable)
+            end
+          end
+
+          context 'lb' do
+            require_topology :load_balanced
+
+            it 'fails the operation after successful server selection' do
+              lambda do
+                client.database.command(ping: 1)
+              end.should raise_error(Mongo::Error::SocketTimeoutError, /socket took over.*to connect/)
+            end
           end
         end
 
@@ -412,7 +447,7 @@ describe Mongo::Client do
             end.should_not raise_error
           end
 
-          it 'fails operations due to very small timeout' do
+          it 'fails operations due to very small timeout', retry: 3 do
             lambda do
               client.database.command(ping: 1)
             end.should raise_error(Mongo::Error::SocketTimeoutError)
@@ -1292,6 +1327,192 @@ describe Mongo::Client do
             client.options[:connect].should be :sharded
           end
         end
+
+        context 'load_balanced: true and multiple seeds' do
+          let(:client) do
+            new_local_client_nmio(['127.0.0.1:27017', '127.0.0.2:27017'],
+              load_balanced: true)
+          end
+
+          it 'is rejected' do
+            lambda do
+              client
+            end.should raise_error(ArgumentError, /load_balanced=true cannot be used with multiple seeds/)
+          end
+        end
+
+        context 'load_balanced: false and multiple seeds' do
+          let(:client) do
+            new_local_client_nmio(['127.0.0.1:27017', '127.0.0.2:27017'],
+              load_balanced: false)
+          end
+
+          it 'is accepted' do
+            lambda do
+              client
+            end.should_not raise_error
+            client.options[:load_balanced].should be false
+          end
+        end
+
+        context 'load_balanced: true and direct_connection: true' do
+          let(:client) do
+            new_local_client_nmio(['127.0.0.1:27017'],
+              load_balanced: true, direct_connection: true)
+          end
+
+          it 'is rejected' do
+            lambda do
+              client
+            end.should raise_error(ArgumentError, /direct_connection=true cannot be used with load_balanced=true/)
+          end
+        end
+
+        context 'load_balanced: true and direct_connection: false' do
+          let(:client) do
+            new_local_client_nmio(['127.0.0.1:27017'],
+              load_balanced: true, direct_connection: false)
+          end
+
+          it 'is accepted' do
+            lambda do
+              client
+            end.should_not raise_error
+            client.options[:load_balanced].should be true
+            client.options[:direct_connection].should be false
+          end
+        end
+
+        context 'load_balanced: false and direct_connection: true' do
+          let(:client) do
+            new_local_client_nmio(['127.0.0.1:27017'],
+              load_balanced: false, direct_connection: true)
+          end
+
+          it 'is accepted' do
+            lambda do
+              client
+            end.should_not raise_error
+            client.options[:load_balanced].should be false
+            client.options[:direct_connection].should be true
+          end
+        end
+
+        [:direct, 'direct', :sharded, 'sharded'].each do |v|
+          context "load_balanced: true and connect: #{v.inspect}" do
+            let(:client) do
+              new_local_client_nmio(['127.0.0.1:27017'],
+                load_balanced: true, connect: v)
+            end
+
+            it 'is rejected' do
+              lambda do
+                client
+              end.should raise_error(ArgumentError, /connect=#{v} cannot be used with load_balanced=true/)
+            end
+          end
+        end
+
+        [nil].each do |v|
+          context "load_balanced: true and connect: #{v.inspect}" do
+            let(:client) do
+              new_local_client_nmio(['127.0.0.1:27017'],
+                load_balanced: true, connect: v)
+            end
+
+            it 'is accepted' do
+              lambda do
+                client
+              end.should_not raise_error
+              client.options[:load_balanced].should be true
+              client.options[:connect].should eq v
+            end
+          end
+        end
+
+        [:load_balanced, 'load_balanced'].each do |v|
+          context "load_balanced: true and connect: #{v.inspect}" do
+            let(:client) do
+              new_local_client_nmio(['127.0.0.1:27017'],
+                load_balanced: true, connect: v)
+            end
+
+            it 'is accepted' do
+              lambda do
+                client
+              end.should_not raise_error
+              client.options[:load_balanced].should be true
+              client.options[:connect].should eq v
+            end
+          end
+
+          context "replica_set and connect: #{v.inspect}" do
+            let(:client) do
+              new_local_client_nmio(['127.0.0.1:27017'],
+                replica_set: 'foo', connect: v)
+            end
+
+            it 'is rejected' do
+              lambda do
+                client
+              end.should raise_error(ArgumentError, /connect=load_balanced cannot be used with replica_set option/)
+            end
+          end
+
+          context "direct_connection=true and connect: #{v.inspect}" do
+            let(:client) do
+              new_local_client_nmio(['127.0.0.1:27017'],
+                direct_connection: true, connect: v)
+            end
+
+            it 'is rejected' do
+              lambda do
+                client
+              end.should raise_error(ArgumentError, /Conflicting client options: direct_connection=true and connect=load_balanced/)
+            end
+          end
+
+          context "multiple seed addresses and connect: #{v.inspect}" do
+            let(:client) do
+              new_local_client_nmio(['127.0.0.1:27017', '127.0.0.1:1234'],
+                connect: v)
+            end
+
+            it 'is rejected' do
+              lambda do
+                client
+              end.should raise_error(ArgumentError, /connect=load_balanced cannot be used with multiple seeds/)
+            end
+          end
+        end
+
+        [:replica_set, 'replica_set'].each do |v|
+          context "load_balanced: true and connect: #{v.inspect}" do
+            let(:client) do
+              new_local_client_nmio(['127.0.0.1:27017'],
+                load_balanced: true, connect: v, replica_set: 'x')
+            end
+
+            it 'is rejected' do
+              lambda do
+                client
+              end.should raise_error(ArgumentError, /connect=replica_set cannot be used with load_balanced=true/)
+            end
+          end
+
+          context "load_balanced: true and #{v.inspect} option" do
+            let(:client) do
+              new_local_client_nmio(['127.0.0.1:27017'],
+                load_balanced: true, v => 'rs')
+            end
+
+            it 'is rejected' do
+              lambda do
+                client
+              end.should raise_error(ArgumentError, /load_balanced=true cannot be used with replica_set option/)
+            end
+          end
+        end
       end
 
       context ':bg_error_backtrace option' do
@@ -2306,7 +2527,12 @@ describe Mongo::Client do
       before do
         client.cluster.next_primary
         events = subscriber.select_started_events(Mongo::Monitoring::Event::ServerHeartbeatStarted)
-        events.length.should > 0
+        if ClusterConfig.instance.topology == :load_balanced
+          # No server monitoring in LB topology
+          events.length.should == 0
+        else
+          events.length.should > 0
+        end
       end
 
       it 'does not copy sdam_proc option to new client' do
@@ -2318,7 +2544,12 @@ describe Mongo::Client do
         # Give those some time to be processed.
         sleep 2
 
-        expect(subscriber.started_events.length).to be > 0
+        if ClusterConfig.instance.topology == :load_balanced
+          # No server monitoring in LB topology
+          expect(subscriber.started_events.length).to eq 0
+        else
+          expect(subscriber.started_events.length).to be > 0
+        end
         subscriber.started_events.clear
 
         # If this test takes longer than heartbeat interval,

data/spec/mongo/client_spec.rb

@@ -635,7 +635,7 @@ describe Mongo::Client do
         root_authorized_client.options.merge(heartbeat_frequency: 100, monitoring: true)
       end
 
-      let(:subscriber) { EventSubscriber.new }
+      let(:subscriber) { Mrss::EventSubscriber.new }
 
       let(:client) do
         ClientRegistry.instance.new_local_client(
@@ -939,13 +939,15 @@ describe Mongo::Client do
     end
 
     context 'monitoring present' do
+      require_topology :single, :replica_set, :sharded
+
       let(:client) do
         authorized_client
       end
 
       it 'does not indicate lack of monitoring' do
-        client.summary.should =~ /servers=.*(STANDALONE|PRIMARY|MONGOS)/
-        client.summary.should_not =~ /servers=.*(STANDALONE|PRIMARY|MONGOS).*NO-MONITORING/
+        client.summary.should =~ /servers=.*(?:STANDALONE|PRIMARY|MONGOS)/
+        client.summary.should_not =~ /servers=.*(?:STANDALONE|PRIMARY|MONGOS).*NO-MONITORING/
       end
     end
 
@@ -957,7 +959,7 @@ describe Mongo::Client do
       end
 
       it 'does not indicate lack of monitoring' do
-        client.summary.should =~ /servers=.*(STANDALONE|PRIMARY|MONGOS).*NO-MONITORING/
+        client.summary.should =~ /servers=.*(STANDALONE|PRIMARY|MONGOS|\bLB\b).*NO-MONITORING/
       end
     end
   end

data/spec/mongo/cluster/cursor_reaper_spec.rb

@@ -5,16 +5,18 @@ require 'spec_helper'
 
 describe Mongo::Cluster::CursorReaper do
 
+  let(:cluster) { double('cluster') }
+
   before do
     authorized_collection.drop
   end
 
   let(:reaper) do
-    described_class.new
+    described_class.new(cluster)
   end
 
-  let(:active_cursors) do
-    reaper.instance_variable_get(:@active_cursors)
+  let(:active_cursor_ids) do
+    reaper.instance_variable_get(:@active_cursor_ids)
   end
 
   describe '#intialize' do
@@ -24,16 +26,29 @@ describe Mongo::Cluster::CursorReaper do
     end
 
     it 'initializes a set for the list of active cursors' do
-      expect(reaper.instance_variable_get(:@active_cursors)).to be_a(Set)
+      expect(reaper.instance_variable_get(:@active_cursor_ids)).to be_a(Set)
     end
   end
 
   describe '#schedule_kill_cursor' do
 
-    let(:server) { double('server') }
+    let(:address) { Mongo::Address.new('localhost') }
+    let(:server) do
+      double('server').tap do |server|
+        allow(server).to receive(:address).and_return(address)
+      end
+    end
     let(:cursor_id) { 1 }
-    let(:op_spec_1) { double('op_spec_1') }
-    let(:op_spec_2) { double('op_spec_2') }
+    let(:cursor_kill_spec_1) do
+      Mongo::Cursor::KillSpec.new(
+        cursor_id: cursor_id, coll_name: 'c', db_name: 'd', service_id: nil,
+      )
+    end
+    let(:cursor_kill_spec_2) do
+      Mongo::Cursor::KillSpec.new(
+        cursor_id: cursor_id, coll_name: 'c', db_name: 'q', service_id: nil,
+      )
+    end
     let(:to_kill) { reaper.instance_variable_get(:@to_kill)}
 
     context 'when the cursor is on the list of active cursors' do
@@ -45,36 +60,36 @@ describe Mongo::Cluster::CursorReaper do
       context 'when there is not a list already for the server' do
 
         before do
-          reaper.schedule_kill_cursor(cursor_id, op_spec_1, server)
+          reaper.schedule_kill_cursor(cursor_kill_spec_1, server)
         end
 
         it 'initializes the list of op specs to a set' do
-          expect(to_kill.keys).to eq([ server ])
-          expect(to_kill[server]).to eq(Set.new([op_spec_1]))
+          expect(to_kill.keys).to eq([ address.seed ])
+          expect(to_kill[address.seed]).to eq(Set.new([cursor_kill_spec_1]))
         end
       end
 
       context 'when there is a list of ops already for the server' do
 
         before do
-          reaper.schedule_kill_cursor(cursor_id, op_spec_1, server)
-          reaper.schedule_kill_cursor(cursor_id, op_spec_2, server)
+          reaper.schedule_kill_cursor(cursor_kill_spec_1, server)
+          reaper.schedule_kill_cursor(cursor_kill_spec_2, server)
         end
 
         it 'adds the op to the server list' do
-          expect(to_kill.keys).to eq([ server ])
-          expect(to_kill[server]).to contain_exactly(op_spec_1, op_spec_2)
+          expect(to_kill.keys).to eq([ address.seed ])
+          expect(to_kill[address.seed]).to contain_exactly(cursor_kill_spec_1, cursor_kill_spec_2)
         end
 
         context 'when the same op is added more than once' do
 
           before do
-            reaper.schedule_kill_cursor(cursor_id, op_spec_2, server)
+            reaper.schedule_kill_cursor(cursor_kill_spec_2, server)
           end
 
           it 'does not allow duplicates ops for a server' do
-            expect(to_kill.keys).to eq([ server ])
-            expect(to_kill[server]).to contain_exactly(op_spec_1, op_spec_2)
+            expect(to_kill.keys).to eq([ address.seed ])
+            expect(to_kill[address.seed]).to contain_exactly(cursor_kill_spec_1, cursor_kill_spec_2)
           end
         end
       end
@@ -83,7 +98,7 @@ describe Mongo::Cluster::CursorReaper do
     context 'when the cursor is not on the list of active cursors' do
 
       before do
-        reaper.schedule_kill_cursor(cursor_id, op_spec_1, server)
+        reaper.schedule_kill_cursor(cursor_kill_spec_1, server)
       end
 
       it 'does not add the kill cursors op spec to the list' do
@@ -131,7 +146,7 @@ describe Mongo::Cluster::CursorReaper do
       end
 
       it 'registers the cursor id as active' do
-        expect(active_cursors).to eq(Set.new([2]))
+        expect(active_cursor_ids).to eq(Set.new([2]))
       end
     end
   end
@@ -146,7 +161,7 @@ describe Mongo::Cluster::CursorReaper do
       end
 
       it 'removes the cursor id' do
-        expect(active_cursors.size).to eq(0)
+        expect(active_cursor_ids.size).to eq(0)
       end
     end
   end
@@ -174,7 +189,7 @@ describe Mongo::Cluster::CursorReaper do
     around do |example|
       authorized_collection.insert_many(docs)
       periodic_executor.stop!
-      cluster.schedule_kill_cursor(cursor.id, cursor.send(:kill_cursors_op_spec),
+      cluster.schedule_kill_cursor(cursor.kill_spec,
                                    cursor.instance_variable_get(:@server))
       periodic_executor.flush
       example.run

data/spec/mongo/cluster/periodic_executor_spec.rb

@@ -5,8 +5,10 @@ require 'spec_helper'
 
 describe Mongo::Cluster::PeriodicExecutor do
 
+  let(:cluster) { double('cluster') }
+
   let(:executor) do
-    described_class.new
+    described_class.new(cluster)
   end
 
   describe '#log_warn' do

data/spec/mongo/cluster_spec.rb

@@ -41,6 +41,34 @@ describe Mongo::Cluster do
       end
     end
 
+    context 'when topology is load-balanced' do
+      require_topology :load_balanced
+
+      it 'emits SDAM events' do
+        allow(monitoring).to receive(:succeeded)
+
+        register_cluster(
+          described_class.new(
+            SpecConfig.instance.addresses,
+            monitoring,
+            SpecConfig.instance.test_options
+            )
+          )
+
+          expect(monitoring).to have_received(:succeeded).with(
+            Mongo::Monitoring::TOPOLOGY_OPENING, any_args
+          )
+          expect(monitoring).to have_received(:succeeded).with(
+            Mongo::Monitoring::TOPOLOGY_CHANGED, any_args
+          ).twice
+          expect(monitoring).to have_received(:succeeded).with(
+            Mongo::Monitoring::SERVER_OPENING, any_args
+          )
+          expect(monitoring).to have_received(:succeeded).with(
+            Mongo::Monitoring::SERVER_DESCRIPTION_CHANGED, any_args
+          )
+      end
+    end
   end
 
   describe '#==' do
@@ -334,7 +362,7 @@ describe Mongo::Cluster do
       end
 
       let(:monitoring) { Mongo::Monitoring.new }
-      let(:subscriber) { EventSubscriber.new }
+      let(:subscriber) { Mrss::EventSubscriber.new }
 
       it 'publishes server closed event once' do
         monitoring.subscribe(Mongo::Monitoring::SERVER_CLOSED, subscriber)
@@ -425,7 +453,7 @@ describe Mongo::Cluster do
     end
 
     let(:primary_candidates) do
-      if cluster.single?
+      if cluster.single? || cluster.load_balanced?
         cluster.servers
       elsif cluster.sharded?
         cluster.servers
@@ -611,7 +639,17 @@ describe Mongo::Cluster do
             monitoring_io: false, server_selection_timeout: 0.183))
       end
 
-      it_behaves_like 'does not support sessions'
+      context 'in load-balanced topology' do
+        require_topology :load_balanced
+
+        it_behaves_like 'supports sessions'
+      end
+
+      context 'not in load-balanced topology' do
+        require_topology :single, :replica_set, :sharded
+
+        it_behaves_like 'does not support sessions'
+      end
     end
 
     context 'when client has contacted servers and then disconnected' do
@@ -761,6 +799,9 @@ describe Mongo::Cluster do
     let(:default_address) { SpecConfig.instance.addresses.first }
 
     context 'cluster has unknown servers' do
+      # Servers are never unknown in load-balanced topology.
+      require_topology :single, :replica_set, :sharded
+
       it 'includes unknown servers' do
         cluster.servers_list.each do |server|
           expect(server).to be_unknown