mongo 2.10.5 → 2.11.0.rc0

data/spec/integration/sdam_error_handling_spec.rb

@@ -1,9 +1,7 @@
 require 'spec_helper'
 
 describe 'SDAM error handling' do
-  before(:all) do
-    ClientRegistry.instance.close_all_clients
-  end
+  clean_slate_for_all
 
   # These tests operate on specific servers, and don't work in a multi
   # shard cluster where multiple servers are equally eligible
@@ -16,63 +14,72 @@ describe 'SDAM error handling' do
   shared_examples_for 'marks server unknown' do
     it 'marks server unknown' do
       expect(server).not_to be_unknown
-      operation
-      expect(server).to be_unknown
+      RSpec::Mocks.with_temporary_scope do
+        operation
+        expect(server).to be_unknown
+      end
     end
   end
 
   shared_examples_for 'does not mark server unknown' do
     it 'does not mark server unknown' do
       expect(server).not_to be_unknown
-      operation
-      expect(server).not_to be_unknown
+      RSpec::Mocks.with_temporary_scope do
+        operation
+        expect(server).not_to be_unknown
+      end
     end
   end
 
   shared_examples_for 'requests server scan' do
     it 'requests server scan' do
-      expect(server.monitor.scan_semaphore).to receive(:signal)
-      operation
+      RSpec::Mocks.with_temporary_scope do
+        expect(server.scan_semaphore).to receive(:signal)
+        operation
+      end
     end
   end
 
   shared_examples_for 'does not request server scan' do
     it 'does not request server scan' do
-      expect(server.monitor.scan_semaphore).not_to receive(:signal)
-      operation
+      RSpec::Mocks.with_temporary_scope do
+        expect(server.scan_semaphore).not_to receive(:signal)
+        operation
+      end
     end
   end
 
   shared_examples_for 'clears connection pool' do
     it 'clears connection pool' do
       generation = server.pool.generation
-      operation
-      new_generation = server.pool.generation
-      # Temporary hack to allow repeated pool clears
-      expect(new_generation).to be >= generation + 1
+      RSpec::Mocks.with_temporary_scope do
+        operation
+        new_generation = server.pool.generation
+        expect(new_generation).to eq(generation + 1)
+      end
     end
   end
 
   shared_examples_for 'does not clear connection pool' do
     it 'does not clear connection pool' do
       generation = server.pool.generation
-      operation
-      new_generation = server.pool.generation
-      expect(new_generation).to eq(generation)
+      RSpec::Mocks.with_temporary_scope do
+        operation
+        new_generation = server.pool.generation
+        expect(new_generation).to eq(generation)
+      end
     end
   end
 
   describe 'when there is an error during an operation' do
 
     before do
-      wait_for_all_servers(client.cluster)
+      client.cluster.next_primary
+      stop_monitoring(client)
       # we also need a connection to the primary so that our error
       # expectations do not get triggered during handshakes which
       # have different behavior from non-handshake errors
       client.database.command(ping: 1)
-      client.cluster.servers_list.each do |server|
-        server.monitor.stop!
-      end
     end
 
     let(:operation) do
@@ -89,8 +96,7 @@ describe 'SDAM error handling' do
       context 'server 4.2 or higher' do
         min_server_fcv '4.2'
 
-        # Due to RUBY-1894 backport, the pool is cleared here
-        it_behaves_like 'clears connection pool'
+        it_behaves_like 'does not clear connection pool'
       end
 
       context 'server 4.0 or lower' do
@@ -183,7 +189,7 @@ describe 'SDAM error handling' do
     let(:operation) do
       expect(server.monitor.connection).not_to be nil
       expect(server.monitor.connection).to receive(:ismaster).at_least(:once).and_raise(exception)
-      server.monitor.scan_semaphore.broadcast
+      server.scan_semaphore.broadcast
       6.times do
         sleep 0.5
         if server.unknown?

data/spec/integration/sdam_events_spec.rb

@@ -3,10 +3,6 @@ require 'spec_helper'
 describe 'SDAM events' do
   let(:subscriber) { Mongo::SDAMMonitoring::TestSubscriber.new }
 
-  before do
-    ClientRegistry.instance.close_all_clients
-  end
-
   describe 'server closed event' do
     it 'is published when client is closed' do
       client = ClientRegistry.instance.new_local_client(
@@ -17,7 +13,7 @@ describe 'SDAM events' do
       client.database.command(ismaster: 1)
       expect(subscriber.events).to be_empty
 
-      client.close(true)
+      client.close
 
       expect(subscriber.events).not_to be_empty
       event = subscriber.first_event('server_closed_event')
@@ -35,7 +31,7 @@ describe 'SDAM events' do
       client.database.command(ismaster: 1)
       expect(subscriber.events).to be_empty
 
-      client.close(true)
+      client.close
 
       expect(subscriber.events).not_to be_empty
       event = subscriber.first_event('topology_closed_event')

data/spec/integration/server_monitor_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe 'Server::Monitor' do
+
+  let(:client) do
+    new_local_client([ClusterConfig.instance.primary_address_str],
+      SpecConfig.instance.test_options.merge(SpecConfig.instance.auth_options.merge(
+        heartbeat_frequency: 1)))
+  end
+
+  it 'refreshes server descriptions in background', retry: 3 do
+    server = client.cluster.next_primary
+
+    expect(server.description).not_to be_unknown
+
+    server.unknown!
+
+    # This is racy, especially in JRuby, because the monitor may have
+    # already run and updated the description. Because of this we retry
+    # the test a few times.
+    expect(server.description).to be_unknown
+
+    # Wait for background thread to update the description
+    sleep 1.5
+
+    expect(server.description).not_to be_unknown
+  end
+end

data/spec/integration/server_selector_spec.rb

@@ -31,7 +31,7 @@ describe 'Server selector' do
           result
         end.to raise_error(Mongo::Error::NoServerAvailable)
         time_passed = Time.now - start_time
-        expect(time_passed < 1).to be true
+        expect(time_passed).to be < 1
       end
     end
 
@@ -39,7 +39,7 @@ describe 'Server selector' do
       context 'there is a known primary' do
         before do
           client.cluster.next_primary
-          client.close(true)
+          client.close
           expect(client.cluster.connected?).to be false
         end
 
@@ -51,7 +51,7 @@ describe 'Server selector' do
       context 'there is no known primary' do
         before do
           primary_server = client.cluster.next_primary
-          client.close(true)
+          client.close
           expect(client.cluster.connected?).to be false
           primary_server.unknown!
         end
@@ -66,10 +66,12 @@ describe 'Server selector' do
 
     context 'monitoring thread is dead' do
       before do
-        client.cluster.servers.first.monitor.instance_variable_get('@thread').kill
+        client.cluster.servers.each do |server|
+          server.monitor.instance_variable_get('@thread').kill
+        end
         server = client.cluster.next_primary
         if server
-          server.monitor.instance_variable_set('@description', Mongo::Server::Description.new({}))
+          server.instance_variable_set('@description', Mongo::Server::Description.new({}))
         end
       end
 

data/spec/integration/srv_monitoring_spec.rb

@@ -0,0 +1,360 @@
+require 'spec_helper'
+
+describe 'SRV Monitoring' do
+  context 'with SRV lookups mocked at Resolver' do
+    let(:srv_result) do
+      double('srv result').tap do |result|
+        allow(result).to receive(:empty?).and_return(false)
+        allow(result).to receive(:address_strs).and_return(
+          [ClusterConfig.instance.primary_address_str])
+      end
+    end
+
+    let(:client) do
+      allow_any_instance_of(Mongo::Srv::Resolver).to receive(:get_records).and_return(srv_result)
+      allow_any_instance_of(Mongo::Srv::Resolver).to receive(:get_txt_options_string)
+
+      new_local_client_nmio('mongodb+srv://foo.a.b', server_selection_timeout: 3.15)
+    end
+
+    context 'standalone/replica set' do
+      require_topology :single, :replica_set
+
+      it 'does not create SRV monitor' do
+        expect(client.cluster.topology).to be_a(Mongo::Cluster::Topology::Unknown)
+
+        client.cluster.run_sdam_flow(
+          Mongo::Server::Description.new(ClusterConfig.instance.primary_address_str),
+          ClusterConfig.instance.primary_description,
+        )
+
+        expect(client.cluster.topology).not_to be_a(Mongo::Cluster::Topology::Unknown)
+
+        expect(client.cluster.instance_variable_get('@srv_monitor')).to be nil
+      end
+    end
+
+    context 'sharded cluster' do
+      require_topology :sharded
+
+      it 'creates SRV monitor' do
+        expect(client.cluster.topology).to be_a(Mongo::Cluster::Topology::Unknown)
+
+        # Since we force the cluster to run sdam flow which creates a monitor,
+        # we need to manually adjust its state.
+        client.cluster.instance_variable_set('@connecting', true)
+
+        client.cluster.run_sdam_flow(
+          Mongo::Server::Description.new(ClusterConfig.instance.primary_address_str),
+          ClusterConfig.instance.primary_description,
+        )
+
+        expect(client.cluster.topology).to be_a(Mongo::Cluster::Topology::Sharded)
+
+        expect(client.cluster.instance_variable_get('@srv_monitor')).to be_a(Mongo::Cluster::SrvMonitor)
+
+        # Close the client in the test rather than allowing our post-test cleanup
+        # to take care of it, since the client references test doubles.
+        client.close
+      end
+    end
+  end
+
+  # These tests require a sharded cluster to be launched on localhost:27017
+  # and localhost:27018, plus internet connectivity for SRV record lookups.
+  context 'end to end' do
+    require_default_port_deployment
+
+    # JRuby apparently does not implement non-blocking UDP I/O which is used
+    # by RubyDNS:
+    # NotImplementedError: recvmsg_nonblock is not implemented
+    fails_on_jruby
+
+    before(:all) do
+      require 'support/dns'
+    end
+
+    let(:uri) do
+      "mongodb+srv://test-fake.test.build.10gen.cc/?tls=#{SpecConfig.instance.ssl?}&tlsInsecure=true"
+    end
+
+    let(:logger) do
+      Logger.new(STDERR, level: Logger::DEBUG)
+    end
+
+    let(:client) do
+      new_local_client(uri,
+        server_selection_timeout: 3.16,
+        resolv_options: {
+          nameserver: 'localhost',
+          nameserver_port: [['localhost', 5300], ['127.0.0.1', 5300]],
+        },
+        logger: logger,
+      )
+    end
+
+    before do
+      # Expedite the polling process
+      allow_any_instance_of(Mongo::Cluster::SrvMonitor).to receive(:scan_interval).and_return(1)
+    end
+
+    context 'sharded cluster' do
+      require_topology :sharded
+      require_multi_shard
+
+      it 'updates topology via SRV records' do
+
+        rules = [
+          ['_mongodb._tcp.test-fake.test.build.10gen.cc', :srv,
+            [0, 0, 27017, 'localhost.test.build.10gen.cc'],
+          ],
+        ]
+
+        mock_dns(rules) do
+          client.cluster.next_primary
+          expect(client.cluster.topology).to be_a(Mongo::Cluster::Topology::Sharded)
+
+          address_strs = client.cluster.servers.map(&:address).map(&:seed).sort
+          expect(address_strs).to eq(%w(
+            localhost.test.build.10gen.cc:27017
+          ))
+        end
+
+        # In Evergreen there are replica set nodes on the next port number
+        # after mongos nodes, therefore the addresses in DNS need to accurately
+        # reflect how many mongos we have.
+
+        rules = [
+          ['_mongodb._tcp.test-fake.test.build.10gen.cc', :srv,
+            [0, 0, 27018, 'localhost.test.build.10gen.cc'],
+            [0, 0, 27017, 'localhost.test.build.10gen.cc'],
+          ],
+        ]
+
+        mock_dns(rules) do
+          15.times do
+            address_strs = client.cluster.servers_list.map(&:address).map(&:seed).sort
+            if address_strs == %w(
+                localhost.test.build.10gen.cc:27017
+                localhost.test.build.10gen.cc:27018
+              )
+            then
+              break
+            end
+            sleep 1
+          end
+
+          address_strs = client.cluster.servers_list.map(&:address).map(&:seed).sort
+          expect(address_strs).to eq(%w(
+            localhost.test.build.10gen.cc:27017
+            localhost.test.build.10gen.cc:27018
+          ))
+        end
+
+        # And because we have only two mongos in Evergreen, test removal
+        # separately here.
+
+        rules = [
+          ['_mongodb._tcp.test-fake.test.build.10gen.cc', :srv,
+            [0, 0, 27018, 'localhost.test.build.10gen.cc'],
+          ],
+        ]
+
+        mock_dns(rules) do
+          15.times do
+            address_strs = client.cluster.servers_list.map(&:address).map(&:seed).sort
+            if address_strs == %w(
+                localhost.test.build.10gen.cc:27018
+              )
+            then
+              break
+            end
+            sleep 1
+          end
+
+          address_strs = client.cluster.servers_list.map(&:address).map(&:seed).sort
+          expect(address_strs).to eq(%w(
+            localhost.test.build.10gen.cc:27018
+          ))
+
+          expect(client.cluster.srv_monitor).to be_running
+        end
+      end
+    end
+
+    context 'unknown topology' do
+
+      it 'updates topology via SRV records' do
+
+        rules = [
+          ['_mongodb._tcp.test-fake.test.build.10gen.cc', :srv,
+            [0, 0, 27999, 'localhost.test.build.10gen.cc'],
+          ],
+        ]
+
+        mock_dns(rules) do
+          expect(client.cluster.topology).to be_a(Mongo::Cluster::Topology::Unknown)
+
+          address_strs = client.cluster.servers_list.map(&:address).map(&:seed).sort
+          expect(address_strs).to eq(%w(
+            localhost.test.build.10gen.cc:27999
+          ))
+        end
+
+        rules = [
+          ['_mongodb._tcp.test-fake.test.build.10gen.cc', :srv,
+            [0, 0, 27998, 'localhost.test.build.10gen.cc'],
+            [0, 0, 27999, 'localhost.test.build.10gen.cc'],
+          ],
+        ]
+
+        mock_dns(rules) do
+          15.times do
+            address_strs = client.cluster.servers_list.map(&:address).map(&:seed).sort
+            if address_strs == %w(
+                localhost.test.build.10gen.cc:27998
+                localhost.test.build.10gen.cc:27999
+              )
+            then
+              break
+            end
+            sleep 1
+          end
+
+          address_strs = client.cluster.servers_list.map(&:address).map(&:seed).sort
+          expect(address_strs).to eq(%w(
+            localhost.test.build.10gen.cc:27998
+            localhost.test.build.10gen.cc:27999
+          ))
+        end
+
+        rules = [
+          ['_mongodb._tcp.test-fake.test.build.10gen.cc', :srv,
+            [0, 0, 27997, 'localhost.test.build.10gen.cc'],
+          ],
+        ]
+
+        mock_dns(rules) do
+          15.times do
+            address_strs = client.cluster.servers_list.map(&:address).map(&:seed).sort
+            if address_strs == %w(
+                localhost.test.build.10gen.cc:27997
+              )
+            then
+              break
+            end
+            sleep 1
+          end
+
+          address_strs = client.cluster.servers_list.map(&:address).map(&:seed).sort
+          expect(address_strs).to eq(%w(
+            localhost.test.build.10gen.cc:27997
+          ))
+
+          expect(client.cluster.topology).to be_a(Mongo::Cluster::Topology::Unknown)
+
+          expect(client.cluster.srv_monitor).to be_running
+        end
+      end
+    end
+
+    context 'unknown to sharded' do
+      require_topology :sharded
+
+      it 'updates topology via SRV records' do
+
+        rules = [
+          ['_mongodb._tcp.test-fake.test.build.10gen.cc', :srv,
+            [0, 0, 27999, 'localhost.test.build.10gen.cc'],
+          ],
+        ]
+
+        mock_dns(rules) do
+          expect(client.cluster.topology).to be_a(Mongo::Cluster::Topology::Unknown)
+
+          address_strs = client.cluster.servers_list.map(&:address).map(&:seed).sort
+          expect(address_strs).to eq(%w(
+            localhost.test.build.10gen.cc:27999
+          ))
+        end
+
+        rules = [
+          ['_mongodb._tcp.test-fake.test.build.10gen.cc', :srv,
+            [0, 0, 27017, 'localhost.test.build.10gen.cc'],
+          ],
+        ]
+
+        mock_dns(rules) do
+          15.times do
+            address_strs = client.cluster.servers.map(&:address).map(&:seed).sort
+            if address_strs == %w(
+                localhost.test.build.10gen.cc:27017
+              )
+            then
+              break
+            end
+            sleep 1
+          end
+
+          address_strs = client.cluster.servers.map(&:address).map(&:seed).sort
+          expect(address_strs).to eq(%w(
+            localhost.test.build.10gen.cc:27017
+          ))
+          expect(client.cluster.topology).to be_a(Mongo::Cluster::Topology::Sharded)
+
+          expect(client.cluster.srv_monitor).to be_running
+        end
+      end
+    end
+
+    context 'unknown to replica set' do
+      require_topology :replica_set
+
+      it 'updates topology via SRV records then stops SRV monitor' do
+
+        rules = [
+          ['_mongodb._tcp.test-fake.test.build.10gen.cc', :srv,
+            [0, 0, 27999, 'localhost.test.build.10gen.cc'],
+          ],
+        ]
+
+        mock_dns(rules) do
+          expect(client.cluster.topology).to be_a(Mongo::Cluster::Topology::Unknown)
+
+          address_strs = client.cluster.servers_list.map(&:address).map(&:seed).sort
+          expect(address_strs).to eq(%w(
+            localhost.test.build.10gen.cc:27999
+          ))
+        end
+
+        rules = [
+          ['_mongodb._tcp.test-fake.test.build.10gen.cc', :srv,
+            [0, 0, 27017, 'localhost.test.build.10gen.cc'],
+          ],
+        ]
+
+        mock_dns(rules) do
+          15.times do
+            address_strs = client.cluster.servers.map(&:address).map(&:seed).sort
+            if address_strs == %w(
+                localhost.test.build.10gen.cc:27017
+              )
+            then
+              break
+            end
+            sleep 1
+          end
+
+          address_strs = client.cluster.servers.map(&:address).map(&:seed).sort
+          # The actual address will be localhost:27017 or 127.0.0.1:27017,
+          # depending on how the replica set is configured.
+          expect(address_strs.any? { |str| str =~ /27017/ }).to be true
+          # Covers both NoPrimary and WithPrimary replica sets
+          expect(client.cluster.topology).to be_a(Mongo::Cluster::Topology::ReplicaSetNoPrimary)
+
+          expect(client.cluster.srv_monitor).not_to be_running
+        end
+      end
+    end
+  end
+end