mongo 2.7.2 → 2.8.0.rc0

data/lib/mongo/socket/tcp.rb

@@ -40,13 +40,14 @@ module Mongo
       # @return [ TCP ] The connected socket instance.
       #
       # @since 2.0.0
-      def connect!(connect_timeout = nil)
-        Timeout.timeout(connect_timeout, Error::SocketTimeoutError) do
+      def connect!
+        Timeout.timeout(options[:connect_timeout], Error::SocketTimeoutError) do
           socket.setsockopt(IPPROTO_TCP, TCP_NODELAY, 1)
           handle_errors { socket.connect(::Socket.pack_sockaddr_in(port, host)) }
           self
         end
       end
+      private :connect!
 
       # Initializes a new TCP socket.
       #
@@ -58,23 +59,21 @@ module Mongo
       # @param [ Integer ] port The port number.
       # @param [ Float ] timeout The socket timeout value.
       # @param [ Integer ] family The socket family.
+      # @param [ Hash ] options The options.
+      #
+      # @option options [ Float ] :connect_timeout Connect timeout.
       #
       # @since 2.0.0
-      def initialize(host, port, timeout, family)
-        @host, @port, @timeout = host, port, timeout
+      def initialize(host, port, timeout, family, options = {})
+        @host, @port, @timeout, @options = host, port, timeout, options
         super(family)
+        connect!
       end
 
-      # This object does not wrap another socket so it's always connectable.
-      #
-      # @example Is the socket connectable?
-      #   socket.connectable?
-      #
-      # @return [ true, false ] If the socket is connectable.
-      #
-      # @since 2.2.5
-      def connectable?
-        true
+      private
+
+      def address
+        "#{host}:#{port} (no TLS)"
       end
     end
   end

data/lib/mongo/socket/unix.rb

@@ -26,21 +26,6 @@ module Mongo
       # @return [ Float ] timeout The socket timeout.
       attr_reader :timeout
 
-      # Establishes a socket connection.
-      #
-      # @example Connect the socket.
-      #   sock.connect!
-      #
-      # @note This method mutates the object by setting the socket
-      #   internally.
-      #
-      # @return [ Unix ] The connected socket instance.
-      #
-      # @since 2.0.0
-      def connect!(connect_timeout = nil)
-        self
-      end
-
       # Initializes a new Unix socket.
       #
       # @example Create the Unix socket.
@@ -48,24 +33,21 @@ module Mongo
       #
       # @param [ String ] path The path.
       # @param [ Float ] timeout The socket timeout value.
+      # @param [ Hash ] options The options.
+      #
+      # @option options [ Float ] :connect_timeout Connect timeout (unused).
       #
       # @since 2.0.0
-      def initialize(path, timeout)
-        @path, @timeout = path, timeout
+      def initialize(path, timeout, options = {})
+        @path, @timeout, @options = path, timeout, options
         @socket = ::UNIXSocket.new(path)
         set_socket_options(@socket)
       end
 
-      # This socket can only be used if the unix socket (@socket) has been created.
-      #
-      # @example Is the socket connectable?
-      #   socket.connectable?
-      #
-      # @return [ true, false ] If the socket is connectable.
-      #
-      # @since 2.2.5
-      def connectable?
-        !!@socket
+      private
+
+      def address
+        path
       end
     end
   end

data/lib/mongo/uri.rb

@@ -155,7 +155,7 @@ module Mongo
     # @since 2.1.0
     UNESCAPED_UNIX_SOCKET = "UNIX domain sockets must be urlencoded.".freeze
 
-    # Error details for a non-urlencoded auth database name.
+    # Error details for a non-urlencoded auth databsae name.
     #
     # @since 2.1.0
     UNESCAPED_DATABASE = "Auth database must be urlencoded.".freeze

data/lib/mongo/version.rb

@@ -17,5 +17,5 @@ module Mongo
   # The current version of the driver.
   #
   # @since 2.0.0
-  VERSION = '2.7.2'.freeze
+  VERSION = '2.8.0.rc0'.freeze
 end

data/spec/integration/auth_spec.rb

@@ -0,0 +1,160 @@
+require 'spec_helper'
+
+describe 'Auth' do
+  describe 'Unauthorized exception message' do
+    let(:server) do
+      authorized_client.cluster.next_primary
+    end
+
+    let(:connection) do
+      Mongo::Server::Connection.new(server, options)
+    end
+
+    before(:all) do
+      # If auth is configured, the test suite uses the configured user
+      # and does not create its own users. However, the configured user may
+      # not have the auth mechanisms we need. Therefore we create a user
+      # for this test without specifying auth mechanisms, which gets us
+      # server default (scram for 4.0, scram & scram256 for 4.2).
+
+      users = ClientRegistry.instance.global_client('root_authorized').use(:admin).database.users
+      unless users.info('existing_user').empty?
+        users.remove('existing_user')
+      end
+      users.create('existing_user', password: 'password')
+    end
+
+    context 'user mechanism not provided' do
+
+      context 'user does not exist' do
+        let(:options) { SpecConfig.instance.ssl_options.merge(
+          user: 'nonexistent_user') }
+
+        before do
+          expect(connection.app_metadata.send(:document)[:saslSupportedMechs]).to eq('admin.nonexistent_user')
+        end
+
+        context 'scram-sha-1 only server' do
+          min_server_fcv '3.0'
+          max_server_version '3.6'
+
+          it 'indicates scram-sha-1 was used' do
+            expect do
+              connection.connect!
+            end.to raise_error(Mongo::Auth::Unauthorized, 'User nonexistent_user (mechanism: scram) is not authorized to access admin (used mechanism: SCRAM-SHA-1)')
+          end
+        end
+
+        context 'scram-sha-256 server' do
+          min_server_fcv '4.0'
+
+          # An existing user on 4.0+ will negotiate scram-sha-256.
+          # A non-existing user on 4.0+ will negotiate scram-sha-1.
+          it 'indicates scram-sha-1 was used' do
+            expect do
+              connection.connect!
+            end.to raise_error(Mongo::Auth::Unauthorized, 'User nonexistent_user (mechanism: scram) is not authorized to access admin (used mechanism: SCRAM-SHA-1)')
+          end
+        end
+      end
+
+      context 'user exists' do
+        let(:options) { SpecConfig.instance.ssl_options.merge(
+          user: 'existing_user', password: 'bogus') }
+
+        before do
+          expect(connection.app_metadata.send(:document)[:saslSupportedMechs]).to eq("admin.existing_user")
+        end
+
+        context 'scram-sha-1 only server' do
+          min_server_fcv '3.0'
+          max_server_version '3.6'
+
+          it 'indicates scram-sha-1 was used' do
+            expect do
+              connection.connect!
+            end.to raise_error(Mongo::Auth::Unauthorized, "User existing_user (mechanism: scram) is not authorized to access admin (used mechanism: SCRAM-SHA-1)")
+          end
+        end
+
+        context 'scram-sha-256 server' do
+          min_server_fcv '4.0'
+
+          # An existing user on 4.0+ will negotiate scram-sha-256.
+          # A non-existing user on 4.0+ will negotiate scram-sha-1.
+          it 'indicates scram-sha-256 was used' do
+            expect do
+              connection.connect!
+            end.to raise_error(Mongo::Auth::Unauthorized, "User existing_user (mechanism: scram256) is not authorized to access admin (used mechanism: SCRAM-SHA-256)")
+          end
+        end
+      end
+    end
+
+    context 'user mechanism is provided' do
+      min_server_fcv '3.0'
+
+      context 'scram-sha-1 requested' do
+        let(:options) { SpecConfig.instance.ssl_options.merge(
+          user: 'nonexistent_user', auth_mech: :scram) }
+
+        it 'indicates scram-sha-1 was requested and used' do
+          expect do
+            connection.connect!
+          end.to raise_error(Mongo::Auth::Unauthorized, 'User nonexistent_user (mechanism: scram) is not authorized to access admin (used mechanism: SCRAM-SHA-1)')
+        end
+      end
+
+      context 'scram-sha-256 requested' do
+        min_server_fcv '4.0'
+
+        let(:options) { SpecConfig.instance.ssl_options.merge(
+          user: 'nonexistent_user', auth_mech: :scram256) }
+
+        it 'indicates scram-sha-256 was requested and used' do
+          expect do
+            connection.connect!
+          end.to raise_error(Mongo::Auth::Unauthorized, 'User nonexistent_user (mechanism: scram256) is not authorized to access admin (used mechanism: SCRAM-SHA-256)')
+        end
+      end
+    end
+
+    context 'attempting to connect to a non-tls server with tls' do
+      require_no_ssl
+
+      let(:options) { {ssl: true} }
+
+      it 'reports host, port and tls status' do
+        begin
+          connection.connect!
+        rescue Mongo::Error::SocketError => exc
+        end
+        expect(exc).not_to be nil
+        expect(exc.message).to include('OpenSSL::SSL::SSLError')
+        expect(exc.message).to include(server.address.to_s)
+        expect(exc.message).to include('TLS')
+        expect(exc.message).not_to include('no TLS')
+      end
+    end
+
+    context 'attempting to connect to a tls server without tls' do
+      require_ssl
+
+      let(:options) { {} }
+
+      it 'reports host, port and tls status' do
+        begin
+          connection.connect!
+        rescue Mongo::Error::SocketError => exc
+        end
+        expect(exc).not_to be nil
+        expect(exc.message).not_to include('OpenSSL::SSL::SSLError')
+        addresses = Socket.getaddrinfo(server.address.host, nil)
+        expect(addresses.any? do |address|
+          exc.message.include?("#{address[2]}:#{server.address.port}")
+        end).to be true
+        expect(exc.message).to include('no TLS')
+      end
+    end
+  end
+end

data/spec/integration/retryable_writes_spec.rb

@@ -1,5 +1,15 @@
 require 'spec_helper'
 
+# The tests raise OperationFailure in socket reads. This is done for
+# convenience to make the tests uniform between socket errors and operation
+# failures; in reality a socket read will never raise OperationFailure as
+# wire protocol parsing code raises this exception. For the purposes of
+# testing retryable writes, it is acceptable to raise OperationFailure in
+# socket reads because both exceptions end up getting handled in the same
+# place by retryable writes code. The SDAM error handling test specifically
+# checks server state (i.e. being marked unknown) and scanning behavior
+# that is performed by the wire protocol code; this test omits scan assertions
+# as otherwise it quickly becomes unwieldy.
 describe 'Retryable writes integration tests' do
   include PrimarySocket
 
@@ -7,21 +17,33 @@ describe 'Retryable writes integration tests' do
     authorized_collection.delete_many
   end
 
+  let(:check_collection) do
+    # Verify data in the collection using another client instance to avoid
+    # having the verification read trigger cluster scans on the writing client
+    subscribed_client[TEST_COLL]
+  end
+
+  let(:primary_connection) do
+    client.database.command(ping: 1)
+    expect(primary_server.pool.send(:queue).pool_size).to eq(1)
+    expect(primary_server.pool.send(:queue).queue_size).to eq(1)
+    primary_server.pool.send(:queue).queue.first
+  end
+
   shared_examples_for 'an operation that is retried' do
 
-    context 'when the operation fails on the first attempt' do
+    context 'when the operation fails on the first attempt and succeeds on the second attempt' do
 
       before do
-        # Note that for writes, server.connectable? is called, refreshing the socket
-        allow(primary_server).to receive(:connectable?).and_return(true)
-        expect(primary_socket).to receive(:write).and_raise(error)
+        wait_for_all_servers(client.cluster)
+
+        allow(primary_socket).to receive(:write).and_raise(error)
       end
 
       context 'when the error is retryable' do
 
         before do
           expect(Mongo::Logger.logger).to receive(:warn).once.and_call_original
-          expect(client.cluster).to receive(:scan!)
         end
 
         context 'when the error is a SocketError' do
@@ -54,6 +76,10 @@ describe 'Retryable writes integration tests' do
             Mongo::Error::OperationFailure.new('not master')
           end
 
+          let(:reply) do
+            make_not_master_reply
+          end
+
           it 'retries writes' do
             operation
             expect(expectation).to eq(successful_retry_value)
@@ -66,13 +92,13 @@ describe 'Retryable writes integration tests' do
         context 'when the error is a non-retryable OperationFailure' do
 
           let(:error) do
-            Mongo::Error::OperationFailure.new('other error')
+            Mongo::Error::OperationFailure.new('other error', code: 123)
           end
 
           it 'does not retry writes' do
             expect {
               operation
-            }.to raise_error(error)
+            }.to raise_error(Mongo::Error::OperationFailure, /other error/)
             expect(expectation).to eq(unsuccessful_retry_value)
           end
         end
@@ -82,8 +108,6 @@ describe 'Retryable writes integration tests' do
     context 'when the operation fails on the first attempt and again on the second attempt' do
 
       before do
-        # Note that for writes, server.connectable? is called, refreshing the socket
-        allow(primary_server).to receive(:connectable?).and_return(true)
         allow(primary_socket).to receive(:write).and_raise(error)
       end
 
@@ -138,9 +162,12 @@ describe 'Retryable writes integration tests' do
         end
       end
 
-      [Mongo::Error::SocketError,
-       Mongo::Error::SocketTimeoutError,
-       Mongo::Error::OperationFailure.new('not master')].each do |retryable_error|
+      [
+        Mongo::Error::SocketError,
+        Mongo::Error::SocketTimeoutError,
+        Mongo::Error::OperationFailure.new('not master'),
+        Mongo::Error::OperationFailure.new('node is recovering'),
+      ].each do |retryable_error|
 
         context "when the first error is a #{retryable_error}" do
 
@@ -149,6 +176,7 @@ describe 'Retryable writes integration tests' do
           end
 
           before do
+            wait_for_all_servers(client.cluster)
             bad_socket = primary_connection.address.socket(primary_connection.socket_timeout,
                                                            primary_connection.send(:ssl_options))
             good_socket = primary_connection.address.socket(primary_connection.socket_timeout,
@@ -163,12 +191,6 @@ describe 'Retryable writes integration tests' do
               Mongo::Error::SocketError
             end
 
-            before do
-              # server selector can call scan! until it finds a server,
-              # hence more than two scan! calls may be issued
-              expect(client.cluster).to receive(:scan!).at_least(:twice).and_call_original
-            end
-
             it 'does not retry writes and raises the second error' do
               expect {
                 operation
@@ -179,12 +201,6 @@ describe 'Retryable writes integration tests' do
 
           context 'when the second error is a SocketTimeoutError' do
 
-            before do
-              # server selector can call scan! until it finds a server,
-              # hence more than two scan! calls may be issued
-              expect(client.cluster).to receive(:scan!).at_least(:twice).and_call_original
-            end
-
             let(:second_error) do
               Mongo::Error::SocketTimeoutError
             end
@@ -199,12 +215,6 @@ describe 'Retryable writes integration tests' do
 
           context 'when the second error is a retryable OperationFailure' do
 
-            before do
-              # server selector can call scan! until it finds a server,
-              # hence more than two scan! calls may be issued
-              expect(client.cluster).to receive(:scan!).at_least(:twice).and_call_original
-            end
-
             let(:second_error) do
               Mongo::Error::OperationFailure.new('not master')
             end
@@ -219,10 +229,6 @@ describe 'Retryable writes integration tests' do
 
           context 'when the second error is a non-retryable OperationFailure' do
 
-            before do
-              expect(client.cluster).to receive(:scan!).once
-            end
-
             let(:second_error) do
               Mongo::Error::OperationFailure.new('other error')
             end
@@ -260,10 +266,7 @@ describe 'Retryable writes integration tests' do
     end
 
     before do
-      # Note that for writes, server.connectable? is called, refreshing the socket
-      allow(primary_server).to receive(:connectable?).and_return(true)
-      expect(primary_socket).to receive(:write).and_raise(Mongo::Error::SocketError)
-      expect(client.cluster).not_to receive(:scan!)
+      expect(primary_socket).to receive(:write).exactly(:once).and_raise(Mongo::Error::SocketError)
     end
 
     it 'does not retry writes' do
@@ -285,10 +288,7 @@ describe 'Retryable writes integration tests' do
     end
 
     before do
-      # Note that for writes, server.connectable? is called, refreshing the socket
-      allow(primary_server).to receive(:connectable?).and_return(true)
       expect(primary_socket).to receive(:write).and_raise(Mongo::Error::SocketError)
-      expect(client.cluster).not_to receive(:scan!)
     end
 
     it 'does not retry writes' do
@@ -369,11 +369,7 @@ describe 'Retryable writes integration tests' do
     context 'when the client has retry_writes set to false' do
 
       let!(:client) do
-        authorized_client.with(retry_writes: false)
-      end
-
-      after do
-        client.close
+        authorized_client_without_retry_writes
       end
 
       context 'when the collection has write concern acknowledged' do
@@ -405,6 +401,7 @@ describe 'Retryable writes integration tests' do
     end
 
     context 'when the client has retry_writes not set' do
+      require_no_retry_writes
 
       let!(:client) do
         authorized_client
@@ -446,7 +443,7 @@ describe 'Retryable writes integration tests' do
     end
 
     let(:expectation) do
-      collection.find(a: 1).count
+      check_collection.find(a: 1).count
     end
 
     let(:successful_retry_value) do
@@ -472,7 +469,7 @@ describe 'Retryable writes integration tests' do
     end
 
     let(:expectation) do
-      collection.find(a: 1).count
+      check_collection.find(a: 1).count
     end
 
     let(:successful_retry_value) do
@@ -498,7 +495,7 @@ describe 'Retryable writes integration tests' do
     end
 
     let(:expectation) do
-      collection.find(a: 1).count
+      check_collection.find(a: 1).count
     end
 
     let(:successful_retry_value) do
@@ -524,7 +521,7 @@ describe 'Retryable writes integration tests' do
     end
 
     let(:expectation) do
-      collection.find(a: 1).count
+      check_collection.find(a: 1).count
     end
 
     let(:successful_retry_value) do
@@ -550,7 +547,7 @@ describe 'Retryable writes integration tests' do
     end
 
     let(:expectation) do
-      collection.find(a: 1).count
+      check_collection.find(a: 1).count
     end
 
     let(:successful_retry_value) do
@@ -576,7 +573,7 @@ describe 'Retryable writes integration tests' do
     end
 
     let(:expectation) do
-      collection.find(a: 3).count
+      check_collection.find(a: 3).count
     end
 
     let(:successful_retry_value) do
@@ -602,7 +599,7 @@ describe 'Retryable writes integration tests' do
     end
 
     let(:expectation) do
-      collection.find(a: 1).count
+      check_collection.find(a: 1).count
     end
 
     let(:successful_retry_value) do
@@ -629,7 +626,7 @@ describe 'Retryable writes integration tests' do
     end
 
     let(:expectation) do
-      collection.find(a: 1).count
+      check_collection.find(a: 1).count
     end
 
     let(:unsuccessful_retry_value) do
@@ -652,7 +649,7 @@ describe 'Retryable writes integration tests' do
     end
 
     let(:expectation) do
-      collection.find(a: 1).count
+      check_collection.find(a: 1).count
     end
 
     let(:unsuccessful_retry_value) do
@@ -676,7 +673,7 @@ describe 'Retryable writes integration tests' do
     end
 
     let(:expectation) do
-      collection.find(a: 1).count
+      check_collection.find(a: 1).count
     end
 
     let(:successful_retry_value) do
@@ -703,7 +700,7 @@ describe 'Retryable writes integration tests' do
     end
 
     let(:expectation) do
-      collection.find(a: 1).count
+      check_collection.find(a: 1).count
     end
 
     let(:unsuccessful_retry_value) do
@@ -726,7 +723,7 @@ describe 'Retryable writes integration tests' do
     end
 
     let(:expectation) do
-      collection.find(a: 1).count
+      check_collection.find(a: 1).count
     end
 
     let(:unsuccessful_retry_value) do