mongo 2.15.0 → 2.17.0

data/spec/mongo/server/connection_spec.rb

@@ -9,6 +9,10 @@ describe Mongo::Server::Connection do
 
   clean_slate_for_all
 
+  let(:generation_manager) do
+    Mongo::Server::ConnectionPool::GenerationManager.new(server: server)
+  end
+
   let!(:address) do
     default_address
   end
@@ -41,7 +45,10 @@ describe Mongo::Server::Connection do
   let(:server_options) { SpecConfig.instance.test_options.merge(monitoring_io: false) }
   let(:server) do
     register_server(
-      Mongo::Server.new(address, cluster, monitoring, listeners, server_options)
+      Mongo::Server.new(address, cluster, monitoring, listeners, server_options.merge(
+        # Normally the load_balancer option is set by the cluster
+        load_balancer: ClusterConfig.instance.topology == :load_balanced,
+      ))
     )
   end
 
@@ -59,6 +66,7 @@ describe Mongo::Server::Connection do
   let(:pool) do
     double('pool').tap do |pool|
       allow(pool).to receive(:close)
+      allow(pool).to receive(:generation_manager).and_return(generation_manager)
     end
   end
 
@@ -81,7 +89,7 @@ describe Mongo::Server::Connection do
     context 'when no socket exists' do
 
       let(:connection) do
-        described_class.new(server, server.options)
+        described_class.new(server, server.options.merge(connection_pool: pool))
       end
 
       let(:result) do
@@ -226,12 +234,15 @@ describe Mongo::Server::Connection do
 
       context 'when #handshake! dependency raises a network exception' do
         let(:exception) do
-          Mongo::Error::SocketError.new
+          Mongo::Error::SocketError.new.tap do |exc|
+            allow(exc).to receive(:service_id).and_return('fake')
+          end
         end
 
         let(:error) do
           # The exception is mutated when notes are added to it
-          expect_any_instance_of(Mongo::Socket).to receive(:write).and_raise(exception.dup)
+          expect_any_instance_of(Mongo::Socket).to receive(:write).and_raise(exception)
+          allow(connection).to receive(:service_id).and_return('fake')
           begin
             connection.connect!
           rescue Exception => e
@@ -310,7 +321,7 @@ describe Mongo::Server::Connection do
     context 'when a socket exists' do
 
       let(:connection) do
-        described_class.new(server, server.options)
+        described_class.new(server, server.options.merge(connection_pool: pool))
       end
 
       let(:socket) do
@@ -369,10 +380,12 @@ describe Mongo::Server::Connection do
           described_class.new(
             server,
             SpecConfig.instance.test_options.merge(
-              :user => 'notauser',
-              :password => 'password',
-              :database => SpecConfig.instance.test_db,
-              :heartbeat_frequency => 30)
+              user: 'notauser',
+              password: 'password',
+              database: SpecConfig.instance.test_db,
+              heartbeat_frequency: 30,
+              connection_pool: pool,
+            )
           )
         end
 
@@ -448,8 +461,16 @@ describe Mongo::Server::Connection do
           )
         end
 
+        let(:exception) do
+          Mongo::Error::SocketError.new.tap do |exc|
+            if server.load_balancer?
+              allow(exc).to receive(:service_id).and_return('fake')
+            end
+          end
+        end
+
         let(:error) do
-          expect_any_instance_of(auth_mechanism).to receive(:login).and_raise(Mongo::Error::SocketError)
+          expect_any_instance_of(auth_mechanism).to receive(:login).and_raise(exception)
           begin
             connection.send(:connect!)
           rescue => ex
@@ -473,9 +494,11 @@ describe Mongo::Server::Connection do
           described_class.new(
             server,
             SpecConfig.instance.test_options.merge(
-              :user => SpecConfig.instance.test_user.name,
-              :password => SpecConfig.instance.test_user.password,
-              :database => SpecConfig.instance.test_user.database )
+              user: SpecConfig.instance.test_user.name,
+              password: SpecConfig.instance.test_user.password,
+              database: SpecConfig.instance.test_user.database,
+              connection_pool: pool,
+            )
           )
         end
 
@@ -563,7 +586,7 @@ describe Mongo::Server::Connection do
     context 'when a socket is not connected' do
 
       let(:connection) do
-        described_class.new(server, server.options)
+        described_class.new(server, server.options.merge(connection_pool: pool))
       end
 
       it 'does not raise an error' do
@@ -574,7 +597,7 @@ describe Mongo::Server::Connection do
     context 'when a socket is connected' do
 
       let(:connection) do
-        described_class.new(server, server.options)
+        described_class.new(server, server.options.merge(connection_pool: pool))
       end
 
       before do
@@ -598,7 +621,8 @@ describe Mongo::Server::Connection do
       described_class.new(
         server,
         SpecConfig.instance.test_options.merge(
-          :database => SpecConfig.instance.test_user.database,
+          database: SpecConfig.instance.test_user.database,
+          connection_pool: pool,
         ).merge(Mongo::Utils.shallow_symbolize_keys(Mongo::Client.canonicalize_ruby_options(
           SpecConfig.instance.credentials_or_external_user(
             user: SpecConfig.instance.test_user.name,
@@ -817,8 +841,10 @@ describe Mongo::Server::Connection do
           # of the test, i.e. to avoid racing with the monitor thread
           # which may put the server back into non-unknown state before
           # we can verify that the server was marked unknown, kill off
-          # the monitor thread
-          server.monitor.instance_variable_get('@thread').kill
+          # the monitor thread.
+          unless ClusterConfig.instance.topology == :load_balanced
+            server.monitor.instance_variable_get('@thread').kill
+          end
         end
       end
 
@@ -844,27 +870,44 @@ describe Mongo::Server::Connection do
           expect(connection).to be_error
         end
 
-        it 'disconnects connection pool' do
-          expect(server.pool).to receive(:disconnect!)
-          result
+        context 'in load-balanced topology' do
+          require_topology :load_balanced
+
+          it 'disconnects connection pool for service id' do
+            connection.service_id.should_not be nil
+
+            RSpec::Mocks.with_temporary_scope do
+              expect(server.pool).to receive(:disconnect!).with(service_id: connection.service_id)
+              result
+            end
+          end
+
+          it 'does not mark server unknown' do
+            expect(server).not_to be_unknown
+            result
+            expect(server).not_to be_unknown
+          end
         end
 
-        it 'marks server unknown' do
-          expect(server).not_to be_unknown
-          result
-          expect(server).to be_unknown
+        context 'in non-lb topologies' do
+          require_topology :single, :replica_set, :sharded
+
+          it 'disconnects connection pool' do
+            expect(server.pool).to receive(:disconnect!)
+            result
+          end
+
+          it 'marks server unknown' do
+            expect(server).not_to be_unknown
+            result
+            expect(server).to be_unknown
+          end
         end
 
         it 'does not request server scan' do
           expect(server.scan_semaphore).not_to receive(:signal)
           result
         end
-
-        it 'marks server unknown' do
-          expect(server).not_to be_unknown
-          result
-          expect(server).to be_unknown
-        end
       end
 
       context 'when a socket timeout occurs' do
@@ -943,7 +986,7 @@ describe Mongo::Server::Connection do
       context 'when the socket_timeout is negative' do
 
         let(:connection) do
-          described_class.new(server, server.options).tap do |connection|
+          described_class.new(server, server.options.merge(connection_pool: pool)).tap do |connection|
             connection.connect!
           end
         end
@@ -1002,7 +1045,7 @@ describe Mongo::Server::Connection do
     context 'when host and port are provided' do
 
       let(:connection) do
-        described_class.new(server, server.options)
+        described_class.new(server, server.options.merge(connection_pool: pool))
       end
 
       it 'sets the address' do
@@ -1017,7 +1060,7 @@ describe Mongo::Server::Connection do
         it 'use incrementing ids' do
           expect(connection.id).to eq(1)
 
-          second_connection = described_class.new(server, server.options)
+          second_connection = described_class.new(server, server.options.merge(connection_pool: pool))
           expect(second_connection.id).to eq(2)
         end
       end
@@ -1025,7 +1068,11 @@ describe Mongo::Server::Connection do
       context 'two pools for different servers' do
         let(:server2) do
           register_server(
-            Mongo::Server.new(address, cluster, monitoring, listeners, server_options)
+            Mongo::Server.new(address, cluster, monitoring, listeners,
+              server_options.merge(
+                load_balancer: ClusterConfig.instance.topology == :load_balanced,
+              )
+            )
           )
         end
 
@@ -1119,10 +1166,11 @@ describe Mongo::Server::Connection do
       let(:connection) do
         described_class.new(
           server,
-          :user => SpecConfig.instance.test_user.name,
-          :password => SpecConfig.instance.test_user.password,
-          :database => SpecConfig.instance.test_db,
-          :auth_mech => :mongodb_cr,
+          user: SpecConfig.instance.test_user.name,
+          password: SpecConfig.instance.test_user.password,
+          database: SpecConfig.instance.test_db,
+          auth_mech: :mongodb_cr,
+          connection_pool: pool,
         )
       end
 
@@ -1155,7 +1203,7 @@ describe Mongo::Server::Connection do
     end
 
     let(:connection) do
-      described_class.new(server, server.options)
+      described_class.new(server, server.options.merge(connection_pool: pool))
     end
 
     context 'when a connect_timeout is in the options' do
@@ -1244,7 +1292,7 @@ describe Mongo::Server::Connection do
   describe '#app_metadata' do
     context 'when all options are identical to server' do
       let(:connection) do
-        described_class.new(server, server.options)
+        described_class.new(server, server.options.merge(connection_pool: pool))
       end
 
       it 'is the same object as server app_metadata' do
@@ -1255,7 +1303,7 @@ describe Mongo::Server::Connection do
 
     context 'when auth options are identical to server' do
       let(:connection) do
-        described_class.new(server, server.options.merge(socket_timeout: 2))
+        described_class.new(server, server.options.merge(socket_timeout: 2, connection_pool: pool))
       end
 
       it 'is the same object as server app_metadata' do
@@ -1268,7 +1316,7 @@ describe Mongo::Server::Connection do
       require_no_external_user
 
       let(:connection) do
-        described_class.new(server, server.options.merge(user: 'foo'))
+        described_class.new(server, server.options.merge(user: 'foo', connection_pool: pool))
       end
 
       it 'is different object from server app_metadata' do
@@ -1282,4 +1330,51 @@ describe Mongo::Server::Connection do
       end
     end
   end
+
+  describe '#generation' do
+
+    context 'non-lb' do
+      require_topology :single, :replica_set, :sharded
+
+      it 'is set' do
+        server.with_connection do |conn|
+          conn.service_id.should be nil
+          conn.generation.should be_a(Integer)
+        end
+      end
+
+      context 'clean slate' do
+        clean_slate
+
+        it 'starts from 1' do
+          server.with_connection do |conn|
+            conn.service_id.should be nil
+            conn.generation.should == 1
+          end
+        end
+      end
+    end
+
+    context 'lb' do
+      require_topology :load_balanced
+
+      it 'is set' do
+        server.with_connection do |conn|
+          conn.service_id.should_not be nil
+          conn.generation.should be_a(Integer)
+        end
+      end
+
+      context 'clean slate' do
+        clean_slate
+
+        it 'starts from 1' do
+          server.with_connection do |conn|
+            conn.service_id.should_not be nil
+            conn.generation.should == 1
+          end
+        end
+      end
+    end
+  end
 end

data/spec/mongo/server/description_spec.rb

@@ -331,7 +331,7 @@ describe Mongo::Server::Description do
       describe '#average_round_trip_time' do
 
         let(:description) do
-          described_class.new(address, { 'secondary' => false }, 4.5)
+          described_class.new(address, { 'secondary' => false }, average_round_trip_time: 4.5)
         end
 
         it 'defaults to nil' do

data/spec/mongo/server/monitor/connection_spec.rb

@@ -136,6 +136,28 @@ describe Mongo::Server::Monitor::Connection do
     end
   end
 
+  describe '#connect!' do
+
+    let(:options) do
+      SpecConfig.instance.test_options.merge(
+        app_metadata: monitor_app_metadata,
+      )
+    end
+
+    context 'when address resolution fails' do
+      let(:connection) { described_class.new(server.address, options) }
+
+      it 'propagates the exception' do
+        connection
+
+        expect(Socket).to receive(:getaddrinfo).and_raise(SocketError.new('Test exception'))
+        lambda do
+          connection.connect!
+        end.should raise_error(SocketError, 'Test exception')
+      end
+    end
+  end
+
   describe '#check_document' do
     context 'with API version' do
       let(:meta) do

data/spec/mongo/server/monitor_spec.rb

@@ -186,16 +186,17 @@ describe Mongo::Server::Monitor do
     context 'when running after a stop' do
       it 'starts the thread' do
         ClientRegistry.instance.close_all_clients
+        sleep 1
         thread
-        sleep 0.5
+        sleep 1
 
         RSpec::Mocks.with_temporary_scope do
           expect(monitor.connection).to receive(:disconnect!).and_call_original
           monitor.stop!
-          sleep 0.5
+          sleep 1
           expect(thread.alive?).to be false
           new_thread = monitor.run!
-          sleep 0.5
+          sleep 1
           expect(new_thread.alive?).to be(true)
         end
       end

data/spec/mongo/server/push_monitor_spec.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Mongo::Server::PushMonitor do
+  before(:all) do
+    ClientRegistry.instance.close_all_clients
+  end
+
+  let(:address) do
+    default_address
+  end
+
+  let(:listeners) do
+    Mongo::Event::Listeners.new
+  end
+
+  let(:monitor_options) do
+    {}
+  end
+
+  let(:monitor_app_metadata) do
+    Mongo::Server::Monitor::AppMetadata.new(
+      server_api: SpecConfig.instance.ruby_options[:server_api],
+    )
+  end
+
+  let(:cluster) do
+    double('cluster').tap do |cluster|
+      allow(cluster).to receive(:run_sdam_flow)
+      allow(cluster).to receive(:heartbeat_interval).and_return(1000)
+    end
+  end
+
+  let(:server) do
+    Mongo::Server.new(address, cluster, Mongo::Monitoring.new, listeners,
+      monitoring_io: false)
+  end
+
+  let(:monitor) do
+    register_background_thread_object(
+      Mongo::Server::Monitor.new(server, listeners, Mongo::Monitoring.new,
+        SpecConfig.instance.test_options.merge(cluster: cluster).merge(monitor_options).update(
+          app_metadata: monitor_app_metadata,
+          push_monitor_app_metadata: monitor_app_metadata))
+    )
+  end
+
+  let(:topology_version) do
+    Mongo::TopologyVersion.new('processId' => BSON::ObjectId.new, 'counter' => 1)
+  end
+
+  let(:check_document) do
+    {hello: 1}
+  end
+
+  let(:push_monitor) do
+    described_class.new(monitor, topology_version, monitor.monitoring,
+      **monitor.options.merge(check_document: check_document))
+  end
+
+  describe '#do_work' do
+    it 'works' do
+      lambda do
+        push_monitor.do_work
+      end.should_not raise_error
+    end
+
+    context 'network error during check' do
+      it 'does not propagate the exception' do
+        push_monitor
+
+        expect(Socket).to receive(:getaddrinfo).and_raise(SocketError.new('Test exception'))
+        lambda do
+          push_monitor.do_work
+        end.should_not raise_error
+      end
+
+      it 'throttles checks' do
+        push_monitor
+
+        start = Mongo::Utils.monotonic_time
+
+        expect(Socket).to receive(:getaddrinfo).and_raise(SocketError.new('Test exception'))
+        lambda do
+          push_monitor.do_work
+        end.should_not raise_error
+
+        expect(Socket).to receive(:getaddrinfo).and_raise(SocketError.new('Test exception'))
+        lambda do
+          push_monitor.do_work
+        end.should_not raise_error
+
+        elapsed = Mongo::Utils.monotonic_time - start
+        elapsed.should > 0.5
+      end
+    end
+  end
+
+end

data/spec/mongo/server_selector_spec.rb

@@ -202,12 +202,7 @@ describe Mongo::ServerSelector do
   describe "#select_server" do
     require_no_linting
 
-    context 'when #select_in_replica_set returns a list of nils' do
-
-      let(:servers) do
-        [ make_server(:primary) ]
-      end
-
+    context 'replica set topology' do
       let(:cluster) do
         double('cluster').tap do |c|
           allow(c).to receive(:connected?).and_return(true)
@@ -223,19 +218,141 @@ describe Mongo::ServerSelector do
           allow(c).to receive(:scan!).and_return(true)
           allow(c).to receive(:options).and_return(server_selection_timeout: 0.1)
           allow(c).to receive(:server_selection_semaphore).and_return(nil)
+          allow(topology).to receive(:compatible?).and_return(true)
         end
       end
 
-      let(:read_pref) do
-        described_class.get(mode: :primary).tap do |pref|
-          allow(pref).to receive(:select_in_replica_set).and_return([ nil, nil ])
+      let(:primary) do
+        make_server(:primary).tap do |server|
+          allow(server).to receive(:features).and_return(double("primary features"))
         end
       end
 
-      it 'raises a NoServerAvailable error' do
-        expect do
-          read_pref.select_server(cluster)
-        end.to raise_exception(Mongo::Error::NoServerAvailable)
+      let(:secondary) do
+        make_server(:secondary).tap do |server|
+          allow(server).to receive(:features).and_return(double("secondary features"))
+        end
+      end
+
+      context "when #select_in_replica_set returns a list of nils" do
+        let(:servers) do
+          [ primary ]
+        end
+
+        let(:read_pref) do
+          described_class.get(mode: :primary).tap do |pref|
+            allow(pref).to receive(:select_in_replica_set).and_return([ nil, nil ])
+          end
+        end
+
+        it 'raises a NoServerAvailable error' do
+          expect do
+            read_pref.select_server(cluster)
+          end.to raise_exception(Mongo::Error::NoServerAvailable)
+        end
+      end
+
+      context "write_aggregation is true" do
+
+        before do
+          # It does not matter for this context whether primary supports secondary wites or not,
+          # but we need to mock out this call.
+          allow(primary.features).to receive(:merge_out_on_secondary_enabled?).and_return(false)
+        end
+
+        context "read preference is primary" do
+          let(:selector) { Mongo::ServerSelector::Primary.new }
+
+          let(:servers) do
+            [ primary, secondary ]
+          end
+
+          [true, false].each do |secondary_support_writes|
+            context "secondary #{secondary_support_writes ? 'supports' : 'does not support' } writes" do
+              it "selects a primary" do
+                allow(secondary.features).to receive(:merge_out_on_secondary_enabled?).and_return(secondary_support_writes)
+
+                expect(selector.select_server(cluster, write_aggregation: true)).to eq(primary)
+              end
+            end
+          end
+        end
+
+        context "read preference is primary preferred" do
+          let(:selector) { Mongo::ServerSelector::PrimaryPreferred.new }
+
+          let(:servers) do
+            [ primary, secondary ]
+          end
+
+          [true, false].each do |secondary_support_writes|
+            context "secondary #{secondary_support_writes ? 'supports' : 'does not support' } writes" do
+              it "selects a primary" do
+                allow(secondary.features).to receive(:merge_out_on_secondary_enabled?).and_return(secondary_support_writes)
+
+                expect(selector.select_server(cluster, write_aggregation: true)).to eq(primary)
+              end
+            end
+          end
+        end
+
+        context "read preference is secondary preferred" do
+          let(:selector) { Mongo::ServerSelector::SecondaryPreferred.new }
+
+          let(:servers) do
+            [ primary, secondary ]
+          end
+
+          context "secondary supports writes" do
+            it "selects a secondary" do
+              allow(secondary.features).to receive(:merge_out_on_secondary_enabled?).and_return(true)
+
+              expect(selector.select_server(cluster, write_aggregation: true)).to eq(secondary)
+            end
+          end
+
+          context "secondary does not support writes" do
+            it "selects a primary" do
+              allow(secondary.features).to receive(:merge_out_on_secondary_enabled?).and_return(false)
+
+              expect(selector.select_server(cluster, write_aggregation: true)).to eq(primary)
+            end
+          end
+        end
+
+        context "read preference is secondary" do
+          let(:selector) { Mongo::ServerSelector::Secondary.new }
+
+          let(:servers) do
+            [ primary, secondary ]
+          end
+
+          context "secondary supports writes" do
+            it "selects a secondary" do
+              allow(secondary.features).to receive(:merge_out_on_secondary_enabled?).and_return(true)
+
+              expect(selector.select_server(cluster, write_aggregation: true)).to eq(secondary)
+            end
+          end
+
+          context "secondary does not support writes" do
+            it "selects a primary" do
+              allow(secondary.features).to receive(:merge_out_on_secondary_enabled?).and_return(false)
+
+              expect(selector.select_server(cluster, write_aggregation: true)).to eq(primary)
+            end
+          end
+
+          context "no secondaries in cluster" do
+            let(:servers) do
+              [ primary ]
+            end
+
+            it "selects a primary" do
+              expect(selector.select_server(cluster, write_aggregation: true)).to eq(primary)
+            end
+          end
+        end
       end
     end
 
@@ -381,8 +498,12 @@ describe Mongo::ServerSelector do
         let(:servers) { [unknown, mongos] }
         let(:selector) { described_class.primary }
 
-        it 'returns the mongos' do
-          expect(selector.select_server(cluster)).to eq(mongos)
+        [true, false].each do |write_aggregation|
+          context "write_aggregation is #{write_aggregation}" do
+            it 'returns the mongos' do
+              expect(selector.select_server(cluster, write_aggregation: write_aggregation)).to eq(mongos)
+            end
+          end
         end
       end
     end