mongo 2.6.2 → 2.16.0

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+require 'lite_spec_helper'
+
+describe Mongo::Server::Monitor::AppMetadata do
+
+  describe '#document' do
+    let(:document) do
+      app_metadata.send(:document)
+    end
+
+    context 'when user is given and auth_mech is not given' do
+      let(:app_metadata) do
+        described_class.new(user: 'foo')
+      end
+
+      it 'does not include saslSupportedMechs' do
+        expect(document).not_to have_key(:saslSupportedMechs)
+      end
+    end
+
+    it_behaves_like 'app metadata document'
+  end
+end

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

@@ -1,35 +1,73 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe Mongo::Server::Monitor::Connection do
+  clean_slate
 
-  let(:client) do
-    authorized_client.with(options)
+  let(:address) do
+    Mongo::Address.new(ClusterConfig.instance.primary_address_str, options)
   end
 
-  let(:address) do
-    client.cluster.next_primary.address
+  declare_topology_double
+
+  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 |cl|
-      allow(cl).to receive(:topology).and_return(double('topology'))
-      allow(cl).to receive(:app_metadata).and_return(Mongo::Cluster::AppMetadata.new(authorized_client.cluster))
+    double('cluster').tap do |cluster|
+      allow(cluster).to receive(:topology).and_return(topology)
+      allow(cluster).to receive(:app_metadata).and_return(Mongo::Server::Monitor::AppMetadata.new({}))
+      allow(cluster).to receive(:options).and_return({})
+      allow(cluster).to receive(:monitor_app_metadata).and_return(monitor_app_metadata)
+      allow(cluster).to receive(:push_monitor_app_metadata).and_return(monitor_app_metadata)
+      allow(cluster).to receive(:heartbeat_interval).and_return(1000)
+      allow(cluster).to receive(:run_sdam_flow)
     end
   end
 
   let(:server) do
     Mongo::Server.new(address,
-                      cluster,
-                      Mongo::Monitoring.new(monitoring: false),
-                      Mongo::Event::Listeners.new, options)
+      cluster,
+      Mongo::Monitoring.new,
+      Mongo::Event::Listeners.new, {monitoring_io: false}.update(options))
   end
 
-  let(:connection) do
-    server.monitor.connection
+  let(:monitor) do
+    metadata = Mongo::Server::Monitor::AppMetadata.new(options)
+    register_background_thread_object(
+      Mongo::Server::Monitor.new(server, server.event_listeners, server.monitoring,
+        {
+          app_metadata: metadata,
+          push_monitor_app_metadata: metadata,
+        }.update(options))
+    ).tap do |monitor|
+      monitor.scan!
+    end
   end
 
-  after do
-    client.close
+  let(:connection) do
+    # NB this connection is set up in the background thread,
+    # when the :scan option to client is changed to default to false
+    # we must wait here for the connection to be established.
+    # Do not call connect! on this connection as then the main thread
+    # will be racing the monitoring thread to connect.
+    monitor.connection.tap do |connection|
+      expect(connection).not_to be nil
+
+      deadline = Time.now + 5
+      while Time.now < deadline
+        if connection.send(:socket)
+          break
+        end
+        sleep 0.1
+      end
+      expect(connection.send(:socket)).not_to be nil
+    end
   end
 
   context 'when a connect_timeout is in the options' do
@@ -37,15 +75,11 @@ describe Mongo::Server::Monitor::Connection do
     context 'when a socket_timeout is in the options' do
 
       let(:options) do
-        TEST_OPTIONS.merge(connect_timeout: 3, socket_timeout: 5)
-      end
-
-      before do
-        connection.connect!
+        SpecConfig.instance.test_options.merge(connect_timeout: 3, socket_timeout: 5)
       end
 
       it 'uses the connect_timeout for the address' do
-        expect(connection.address.send(:connect_timeout)).to eq(3)
+        expect(connection.address.options[:connect_timeout]).to eq(3)
       end
 
       it 'uses the connect_timeout as the socket_timeout' do
@@ -56,15 +90,11 @@ describe Mongo::Server::Monitor::Connection do
     context 'when a socket_timeout is not in the options' do
 
       let(:options) do
-        TEST_OPTIONS.merge(connect_timeout: 3, socket_timeout: nil)
-      end
-
-      before do
-        connection.connect!
+        SpecConfig.instance.test_options.merge(connect_timeout: 3, socket_timeout: nil)
       end
 
       it 'uses the connect_timeout for the address' do
-        expect(connection.address.send(:connect_timeout)).to eq(3)
+        expect(connection.address.options[:connect_timeout]).to eq(3)
       end
 
       it 'uses the connect_timeout as the socket_timeout' do
@@ -78,15 +108,11 @@ describe Mongo::Server::Monitor::Connection do
     context 'when a socket_timeout is in the options' do
 
       let(:options) do
-        TEST_OPTIONS.merge(connect_timeout: nil, socket_timeout: 5)
-      end
-
-      before do
-        connection.connect!
+        SpecConfig.instance.test_options.merge(connect_timeout: nil, socket_timeout: 5)
       end
 
-      it 'uses the default connect_timeout for the address' do
-        expect(connection.address.send(:connect_timeout)).to eq(10)
+      it 'does not specify connect_timeout for the address' do
+        expect(connection.address.options[:connect_timeout]).to be nil
       end
 
       it 'uses the connect_timeout as the socket_timeout' do
@@ -97,15 +123,11 @@ describe Mongo::Server::Monitor::Connection do
     context 'when a socket_timeout is not in the options' do
 
       let(:options) do
-        TEST_OPTIONS.merge(connect_timeout: nil, socket_timeout: nil)
+        SpecConfig.instance.test_options.merge(connect_timeout: nil, socket_timeout: nil)
       end
 
-      before do
-        connection.connect!
-      end
-
-      it 'uses the default connect_timeout for the address' do
-        expect(connection.address.send(:connect_timeout)).to eq(10)
+      it 'does not specify connect_timeout for the address' do
+        expect(connection.address.options[:connect_timeout]).to be nil
       end
 
       it 'uses the connect_timeout as the socket_timeout' do
@@ -113,4 +135,41 @@ describe Mongo::Server::Monitor::Connection do
       end
     end
   end
+
+  describe '#check_document' do
+    context 'with API version' do
+      let(:meta) do
+        Mongo::Server::AppMetadata.new({
+          server_api: { version: '1' }
+        })
+      end
+
+      [false, true].each do |hello_ok|
+        it "returns hello document if server #{ if hello_ok then 'supports' else 'does not support' end } hello" do
+          subject = described_class.new(double("address"), app_metadata: meta)
+          expect(subject).to receive(:hello_ok?).and_return(hello_ok)
+          document = subject.check_document
+          expect(document['hello']).to eq(1)
+        end
+      end
+    end
+
+    context 'without API version' do
+      let(:meta) { Mongo::Server::AppMetadata.new({}) }
+
+      it 'returns legacy hello document' do
+        subject = described_class.new(double("address"), app_metadata: meta)
+        expect(subject).to receive(:hello_ok?).and_return(false)
+        document = subject.check_document
+        expect(document['isMaster']).to eq(1)
+      end
+
+      it 'returns hello document when server responded with helloOk' do
+        subject = described_class.new(double("address"), app_metadata: meta)
+        expect(subject).to receive(:hello_ok?).and_return(true)
+        document = subject.check_document
+        expect(document['hello']).to eq(1)
+      end
+    end
+  end
 end

data/spec/mongo/server/monitor_spec.rb

@@ -1,6 +1,12 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe Mongo::Server::Monitor do
+  before(:all) do
+    ClientRegistry.instance.close_all_clients
+  end
 
   let(:address) do
     default_address
@@ -10,14 +16,41 @@ describe Mongo::Server::Monitor 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(
+      described_class.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
+
   describe '#scan!' do
 
     context 'when calling multiple times in succession' do
 
-      let(:monitor) do
-        described_class.new(address, listeners, TEST_OPTIONS)
-      end
-
       it 'throttles the scans to minimum 500ms' do
         start = Time.now
         monitor.scan!
@@ -26,117 +59,85 @@ describe Mongo::Server::Monitor do
       end
     end
 
-    context 'when the ismaster fails the first time' do
+    context 'when the hello fails the first time' do
 
-      let(:monitor) do
-        described_class.new(address, listeners, TEST_OPTIONS)
+      let(:monitor_options) do
+        {monitoring_io: false}
       end
 
-      let(:socket) do
-        monitor.connection.connect!
-        monitor.connection.__send__(:socket)
-      end
-
-      before do
-        expect(socket).to receive(:write).once.and_raise(Mongo::Error::SocketError)
-        expect(socket).to receive(:write).and_call_original
+      it 'runs sdam flow on unknown description' do
+        expect(monitor).to receive(:check).once.and_raise(Mongo::Error::SocketError)
+        expect(cluster).to receive(:run_sdam_flow)
         monitor.scan!
       end
-
-      it 'retries the ismaster', if: standalone? do
-        expect(monitor.description).to be_standalone
-      end
-
-      it 'retries the ismaster', if: replica_set? do
-        expect(monitor.description).to be_primary
-      end
-
-      it 'retries the ismaster', if: sharded? do
-        expect(monitor.description).to be_mongos
-      end
     end
 
-    context 'when the ismaster command succeeds' do
+    context 'when the hello command succeeds' do
 
-      let(:monitor) do
-        described_class.new(address, listeners, TEST_OPTIONS)
-      end
+      it 'invokes sdam flow' do
+        server.unknown!
+        expect(server.description).to be_unknown
 
-      before do
+        updated_desc = nil
+        expect(cluster).to receive(:run_sdam_flow) do |prev_desc, _updated_desc|
+          updated_desc = _updated_desc
+        end
         monitor.scan!
-      end
-
-      it 'updates the server description', if: standalone? do
-        expect(monitor.description).to be_standalone
-      end
 
-      it 'updates the server description', if: replica_set? do
-        expect(monitor.description).to be_primary
-      end
-
-      it 'updates the server description', if: sharded? do
-        expect(monitor.description).to be_mongos
+        expect(updated_desc).not_to be_unknown
       end
     end
 
-    context 'when the ismaster command fails' do
+    context 'when the hello command fails' do
 
       context 'when no server is running on the address' do
 
-        let(:bad_address) do
+        let(:address) do
           Mongo::Address.new('127.0.0.1:27050')
         end
 
-        let(:monitor) do
-          described_class.new(bad_address, listeners)
-        end
-
         before do
+          server.unknown!
+          expect(server.description).to be_unknown
           monitor.scan!
         end
 
         it 'keeps the server unknown' do
-          expect(monitor.description).to be_unknown
+          expect(server.description).to be_unknown
         end
       end
 
       context 'when the socket gets an exception' do
 
-        let(:bad_address) do
+        let(:address) do
           default_address
         end
 
-        let(:monitor) do
-          described_class.new(bad_address, listeners)
-        end
-
-        let(:socket) do
-          monitor.connection.connect!
-          monitor.connection.__send__(:socket)
-        end
-
         before do
-          expect(socket).to receive(:write).twice.and_raise(Mongo::Error::SocketError)
+          server.unknown!
+          expect(server.description).to be_unknown
+          expect(monitor).to receive(:check).and_raise(Mongo::Error::SocketError)
           monitor.scan!
         end
 
         it 'keeps the server unknown' do
-          expect(monitor.description).to be_unknown
+          expect(server.description).to be_unknown
         end
 
         it 'disconnects the connection' do
-          expect(monitor.connection).to_not be_connected
+          expect(monitor.connection).to be nil
         end
       end
     end
   end
 
+=begin heartbeat interval is now taken out of cluster, monitor has no useful options
   describe '#heartbeat_frequency' do
 
     context 'when an option is provided' do
 
-      let(:monitor) do
-        described_class.new(address, listeners, :heartbeat_frequency => 5)
+      let(:monitor_options) do
+        {:heartbeat_frequency => 5}
       end
 
       it 'returns the option' do
@@ -146,8 +147,8 @@ describe Mongo::Server::Monitor do
 
     context 'when no option is provided' do
 
-      let(:monitor) do
-        described_class.new(address, listeners)
+      let(:monitor_options) do
+        {:heartbeat_frequency => nil}
       end
 
       it 'defaults to 10' do
@@ -155,29 +156,10 @@ describe Mongo::Server::Monitor do
       end
     end
   end
+=end
 
   describe '#run!' do
 
-    let(:monitor) do
-      described_class.new(address, listeners, :heartbeat_frequency => 1)
-    end
-
-    before do
-      monitor.run!
-      sleep(1)
-    end
-
-    it 'refreshes the server on the provided interval' do
-      expect(monitor.description).to_not be_nil
-    end
-  end
-
-  describe '#restart!' do
-
-    let(:monitor) do
-      described_class.new(address, listeners, TEST_OPTIONS)
-    end
-
     let!(:thread) do
       monitor.run!
     end
@@ -200,26 +182,43 @@ describe Mongo::Server::Monitor do
         expect(monitor.restart!).not_to be(thread)
       end
     end
+
+    context 'when running after a stop' do
+      it 'starts the thread' do
+        ClientRegistry.instance.close_all_clients
+        sleep 1
+        thread
+        sleep 1
+
+        RSpec::Mocks.with_temporary_scope do
+          expect(monitor.connection).to receive(:disconnect!).and_call_original
+          monitor.stop!
+          sleep 1
+          expect(thread.alive?).to be false
+          new_thread = monitor.run!
+          sleep 1
+          expect(new_thread.alive?).to be(true)
+        end
+      end
+    end
   end
 
   describe '#stop' do
 
-    let(:monitor) do
-      described_class.new(address, listeners, TEST_OPTIONS)
-    end
-
-    let!(:thread) do
+    let(:thread) do
       monitor.run!
     end
 
-    before do
-      expect(monitor.connection).to receive(:disconnect!).and_call_original
-      monitor.stop!
-      sleep(1)
-    end
-
     it 'kills the monitor thread' do
-      expect(thread.stop?).to be(true)
+      ClientRegistry.instance.close_all_clients
+      thread
+      sleep 0.5
+
+      RSpec::Mocks.with_temporary_scope do
+        expect(monitor.connection).to receive(:disconnect!).and_call_original
+        monitor.stop!
+        expect(thread.alive?).to be(false)
+      end
     end
   end
 
@@ -231,18 +230,96 @@ describe Mongo::Server::Monitor do
         1
       end
 
-      let(:monitor) do
-        described_class.new(address, listeners, TEST_OPTIONS.merge(connect_timeout: connect_timeout))
+      let(:monitor_options) do
+        {connect_timeout: connect_timeout}
       end
 
       it 'sets the value as the timeout on the connection' do
-        expect(monitor.connection.timeout).to eq(connect_timeout)
+        monitor.scan!
+        expect(monitor.connection.socket_timeout).to eq(connect_timeout)
       end
 
       it 'set the value as the timeout on the socket' do
-        monitor.connection.connect!
+        monitor.scan!
         expect(monitor.connection.send(:socket).timeout).to eq(connect_timeout)
       end
     end
   end
+
+  describe '#log_warn' do
+    it 'works' do
+      expect do
+        monitor.log_warn('test warning')
+      end.not_to raise_error
+    end
+  end
+
+  describe '#do_scan' do
+
+    let(:result) { monitor.send(:do_scan) }
+
+    it 'returns a hash' do
+      expect(result).to be_a(Hash)
+    end
+
+    it 'is successful' do
+      expect(result['ok']).to eq(1.0)
+    end
+
+    context 'network error during check' do
+      let(:result) do
+        expect(monitor).to receive(:check).and_raise(IOError)
+        # The retry is done on a new socket instance.
+        #expect(socket).to receive(:write).and_call_original
+
+        monitor.send(:do_scan)
+      end
+
+      it 'adds server diagnostics' do
+        expect(Mongo::Logger.logger).to receive(:warn) do |msg|
+          # The "on <address>" and "for <address>" bits are in different parts
+          # of the message.
+          expect(msg).to match(/#{server.address}/)
+        end
+        expect(result).to be_a(Hash)
+      end
+    end
+
+    context 'network error during connection' do
+      let(:options) { SpecConfig.instance.test_options }
+
+      let(:expected_message) { "MONGODB | Failed to handshake with #{address}: Mongo::Error::SocketError: test error" }
+
+      before do
+        monitor.connection.should be nil
+      end
+
+      it 'logs a warning' do
+        # Note: the mock call below could mock do_write and raise IOError.
+        # It is correct in raising Error::SocketError if mocking write
+        # which performs exception mapping.
+        expect_any_instance_of(Mongo::Socket).to receive(:write).and_raise(Mongo::Error::SocketError, 'test error')
+
+        messages = []
+        expect(Mongo::Logger.logger).to receive(:warn).at_least(:once) do |msg|
+          messages << msg
+        end
+
+        monitor.scan!.should be_unknown
+
+        messages.any? { |msg| msg.include?(expected_message) }.should be true
+      end
+
+      it 'adds server diagnostics' do
+        # Note: the mock call below could mock do_write and raise IOError.
+        # It is correct in raising Error::SocketError if mocking write
+        # which performs exception mapping.
+        expect_any_instance_of(Mongo::Socket).to receive(:write).and_raise(Mongo::Error::SocketError, 'test error')
+
+        expect do
+          monitor.send(:check)
+        end.to raise_error(Mongo::Error::SocketError, /#{server.address}/)
+      end
+    end
+  end
 end

data/spec/mongo/server/round_trip_time_averager_spec.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Mongo::Server::RoundTripTimeAverager do
+  let(:averager) { Mongo::Server::RoundTripTimeAverager.new }
+
+  describe '#update_average_round_trip_time' do
+    context 'no existing average rtt' do
+      it 'updates average rtt' do
+        averager.instance_variable_set('@last_round_trip_time', 5)
+        averager.send(:update_average_round_trip_time)
+        expect(averager.average_round_trip_time).to eq(5)
+      end
+    end
+
+    context 'with existing average rtt' do
+      it 'averages with existing average rtt' do
+        averager.instance_variable_set('@last_round_trip_time', 5)
+        averager.instance_variable_set('@average_round_trip_time', 10)
+        averager.send(:update_average_round_trip_time)
+        expect(averager.average_round_trip_time).to eq(9)
+      end
+    end
+  end
+
+  describe '#measure' do
+    context 'block does not raise' do
+      it 'updates average rtt' do
+        expect(averager).to receive(:update_average_round_trip_time)
+        averager.measure do
+        end
+      end
+    end
+
+    context 'block raises' do
+      it 'does not update average rtt' do
+        expect(averager).not_to receive(:update_average_round_trip_time)
+        lambda do
+          averager.measure do
+            raise "Problem"
+          end
+        end.should raise_error(/Problem/)
+      end
+    end
+  end
+end