mongo 2.15.1 → 2.16.0.alpha1

data/spec/mongo/server/connection_pool_spec.rb

@@ -317,6 +317,11 @@ describe Mongo::Server::ConnectionPool do
     end
 
     context 'connection of the same generation as pool' do
+      # These tests are also applicable to load balancers, but
+      # require different setup and assertions because load balancers
+      # do not have a single global generation.
+      require_topology :single, :replica_set, :sharded
+
       before do
         expect(pool.generation).to eq(connection.generation)
       end
@@ -349,6 +354,11 @@ describe Mongo::Server::ConnectionPool do
     end
 
     context 'connection of earlier generation than pool' do
+      # These tests are also applicable to load balancers, but
+      # require different setup and assertions because load balancers
+      # do not have a single global generation.
+      require_topology :single, :replica_set, :sharded
+
       let(:connection) do
         pool.check_out.tap do |connection|
           expect(connection).to receive(:generation).at_least(:once).and_return(0)
@@ -364,6 +374,11 @@ describe Mongo::Server::ConnectionPool do
     end
 
     context 'connection of later generation than pool' do
+      # These tests are also applicable to load balancers, but
+      # require different setup and assertions because load balancers
+      # do not have a single global generation.
+      require_topology :single, :replica_set, :sharded
+
       let(:connection) do
         pool.check_out.tap do |connection|
           expect(connection).to receive(:generation).at_least(:once).and_return(7)
@@ -449,6 +464,11 @@ describe Mongo::Server::ConnectionPool do
     end
 
     context 'when there is an available connection which is stale' do
+      # These tests are also applicable to load balancers, but
+      # require different setup and assertions because load balancers
+      # do not have a single global generation.
+      require_topology :single, :replica_set, :sharded
+
       let(:options) do
         { max_pool_size: 2, max_idle_time: 0.1 }
       end
@@ -489,13 +509,54 @@ describe Mongo::Server::ConnectionPool do
 
       context 'when the max size is reached' do
 
-        it 'raises a timeout error' do
-          expect(Mongo::Server::Connection).to receive(:new).once.and_call_original
-          expect {
-            pool.check_out
+        context 'without service_id' do
+          it 'raises a timeout error' do
+            expect(Mongo::Server::Connection).to receive(:new).once.and_call_original
             pool.check_out
-          }.to raise_error(::Timeout::Error)
-          expect(pool.size).to eq(1)
+            expect {
+              pool.check_out
+            }.to raise_error(::Timeout::Error)
+            expect(pool.size).to eq(1)
+          end
+        end
+
+        context 'with service_id' do
+          require_topology :load_balanced
+
+          let(:service_id) do
+            pool.with_connection do |connection|
+              connection.service_id.should_not be nil
+              connection.service_id
+            end
+          end
+
+          it 'raises a timeout error' do
+            expect(Mongo::Server::Connection).to receive(:new).once.and_call_original
+            service_id
+
+            pool.check_out(service_id: service_id)
+
+            expect {
+              pool.check_out(service_id: service_id)
+            }.to raise_error(Mongo::Error::ConnectionCheckOutTimeout)
+
+            expect(pool.size).to eq(1)
+          end
+
+          it 'waits for the timeout' do
+            expect(Mongo::Server::Connection).to receive(:new).once.and_call_original
+            service_id
+
+            pool.check_out(service_id: service_id)
+
+            start_time = Mongo::Utils.monotonic_time
+            expect {
+              pool.check_out(service_id: service_id)
+            }.to raise_error(Mongo::Error::ConnectionCheckOutTimeout)
+            elapsed_time = Mongo::Utils.monotonic_time - start_time
+
+            elapsed_time.should > 1
+          end
         end
       end
     end
@@ -541,7 +602,7 @@ describe Mongo::Server::ConnectionPool do
        it 'raises an error and emits ConnectionCheckOutFailedEvent' do
         pool
 
-        subscriber = EventSubscriber.new
+        subscriber = Mrss::EventSubscriber.new
         client.subscribe(Mongo::Monitoring::CONNECTION_POOL, subscriber)
 
         subscriber.clear_events!
@@ -579,6 +640,11 @@ describe Mongo::Server::ConnectionPool do
     end
 
     shared_examples_for 'disconnects and removes all connections in the pool and bumps generation' do
+      # These tests are also applicable to load balancers, but
+      # require different setup and assertions because load balancers
+      # do not have a single global generation.
+      require_topology :single, :replica_set, :sharded
+
       it 'disconnects and removes and bumps' do
         old_connections = []
         pool.instance_variable_get('@available_connections').each do |connection|

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_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/session/session_pool_spec.rb

@@ -5,7 +5,7 @@ require 'spec_helper'
 
 describe Mongo::Session::SessionPool do
   min_server_fcv '3.6'
-  require_topology :replica_set, :sharded
+  require_topology :replica_set, :sharded, :load_balanced
   clean_slate_for_all
 
   let(:cluster) do
@@ -113,10 +113,26 @@ describe Mongo::Session::SessionPool do
           pool.checkout
         end
 
-        it 'disposes of the old session and returns a new one' do
-          expect(checked_out_session).not_to be(old_session_a)
-          expect(checked_out_session).not_to be(old_session_b)
-          expect(pool.instance_variable_get(:@queue)).to be_empty
+        context "in non load-balanced topology" do
+          require_topology :replica_set, :sharded
+
+          it 'disposes of the old session and returns a new one' do
+            old_sessions = [old_session_a, old_session_b]
+            expect(old_sessions).not_to include(pool.checkout)
+            expect(old_sessions).not_to include(pool.checkout)
+            expect(pool.instance_variable_get(:@queue)).to be_empty
+          end
+        end
+
+        context "in load-balanced topology" do
+          require_topology :load_balanced
+
+          it 'doed not dispose of the old session' do
+            old_sessions = [old_session_a, old_session_b]
+            expect(old_sessions).to include(checked_out_session)
+            expect(old_sessions).to include(checked_out_session)
+            expect(pool.instance_variable_get(:@queue)).to be_empty
+          end
         end
       end
     end
@@ -138,10 +154,26 @@ describe Mongo::Session::SessionPool do
         pool.checkin(old_session_b)
       end
 
-      it 'disposes of the old sessions instead of adding them to the pool' do
-        expect(pool.checkout).not_to be(old_session_a)
-        expect(pool.checkout).not_to be(old_session_b)
-        expect(pool.instance_variable_get(:@queue)).to be_empty
+      context "in non load-balanced topology" do
+        require_topology :replica_set, :sharded
+
+        it 'disposes of the old sessions instead of adding them to the pool' do
+          old_sessions = [old_session_a, old_session_b]
+          expect(old_sessions).not_to include(pool.checkout)
+          expect(old_sessions).not_to include(pool.checkout)
+          expect(pool.instance_variable_get(:@queue)).to be_empty
+        end
+      end
+
+      context "in load-balanced topology" do
+        require_topology :load_balanced
+
+        it 'does not dispose of the old sessions' do
+          old_sessions = [old_session_a, old_session_b]
+          expect(old_sessions).to include(pool.checkout)
+          expect(old_sessions).to include(pool.checkout)
+          expect(pool.instance_variable_get(:@queue)).to be_empty
+        end
       end
     end
   end
@@ -160,7 +192,7 @@ describe Mongo::Session::SessionPool do
       pool.checkout
     end
 
-    let(:subscriber) { EventSubscriber.new }
+    let(:subscriber) { Mrss::EventSubscriber.new }
 
     let(:client) do
       authorized_client.tap do |client|

data/spec/mongo/session_transaction_spec.rb

@@ -117,25 +117,15 @@ describe Mongo::Session do
       max_example_run_time 7
 
       it 'times out' do
-        warp = Mongo::Utils.monotonic_time + 200
-        entered = false
+        start = Mongo::Utils.monotonic_time
 
-        Thread.new do
-          until entered
-            sleep 0.1
-          end
-          allow(Mongo::Utils).to receive(:monotonic_time).and_return(warp)
-        end
+        expect(Mongo::Utils).to receive(:monotonic_time).ordered.and_return(start)
+        expect(Mongo::Utils).to receive(:monotonic_time).ordered.and_return(start + 1)
+        expect(Mongo::Utils).to receive(:monotonic_time).ordered.and_return(start + 2)
+        expect(Mongo::Utils).to receive(:monotonic_time).ordered.and_return(start + 200)
 
         expect do
           session.with_transaction do
-            entered = true
-
-            # This sleep is to give the interrupting thread a chance to run,
-            # it significantly affects how much time is burned in this
-            # looping thread
-            sleep 0.1
-
             exc = Mongo::Error::OperationFailure.new('timeout test')
             exc.add_label('TransientTransactionError')
             raise exc
@@ -148,21 +138,23 @@ describe Mongo::Session do
       context "timeout with commit raising with #{label}" do
         max_example_run_time 7
 
+        # JRuby seems to burn through the monotonic time expectations
+        # very quickly and the retries of the transaction get the original
+        # time which causes the transaction to be stuck there.
+        fails_on_jruby
+
         before do
           # create collection if it does not exist
           collection.insert_one(a: 1)
         end
 
-        it 'times out' do
-          warp = Mongo::Utils.monotonic_time + 200
-          entered = false
+        it 'times out', retry: 3 do
+          start = Mongo::Utils.monotonic_time
 
-          Thread.new do
-            until entered
-              sleep 0.1
-            end
-            allow(Mongo::Utils).to receive(:monotonic_time).and_return(warp)
+          10.times do |i|
+            expect(Mongo::Utils).to receive(:monotonic_time).ordered.and_return(start + i)
           end
+          expect(Mongo::Utils).to receive(:monotonic_time).ordered.and_return(start + 200)
 
           exc = Mongo::Error::OperationFailure.new('timeout test')
           exc.add_label(label)
@@ -171,13 +163,6 @@ describe Mongo::Session do
 
           expect do
             session.with_transaction do
-              entered = true
-
-              # This sleep is to give the interrupting thread a chance to run,
-              # it significantly affects how much time is burned in this
-              # looping thread
-              sleep 0.1
-
               collection.insert_one(a: 2)
             end
           end.to raise_error(Mongo::Error::OperationFailure, 'timeout test')

data/spec/mongo/socket/unix_spec.rb

@@ -4,6 +4,7 @@
 require 'spec_helper'
 
 describe Mongo::Socket::Unix do
+  require_unix_socket
 
   let(:path) { "/tmp/mongodb-#{SpecConfig.instance.any_port}.sock" }