mongo 2.12.1 → 2.13.0

data/lib/mongo/server/monitor/app_metadata.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2018-2019 MongoDB, Inc.
+# Copyright (C) 2018-2020 MongoDB Inc.
 
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.

data/lib/mongo/server/monitor/connection.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2015-2019 MongoDB, Inc.
+# Copyright (C) 2015-2020 MongoDB Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -19,20 +19,27 @@ module Mongo
       # This class models the monitor connections and their behavior.
       #
       # @since 2.0.0
+      # @api private
       class Connection < Server::ConnectionCommon
-        include Retryable
-        include Connectable
         include Loggable
 
         # The command used for determining server status.
         #
+        # The case matters here for fail points.
+        #
         # @since 2.2.0
-        ISMASTER = { :ismaster => 1 }.freeze
+        ISMASTER = { isMaster: 1 }.freeze
 
-        # The command used for determining server status formatted for an OP_MSG (server versions >= 3.6).
+        # The command used for determining server status formatted for an
+        # OP_MSG (server versions >= 3.6).
+        #
+        # The case matters here for fail points.
         #
         # @since 2.5.0
-        ISMASTER_OP_MSG = { :ismaster => 1, '$db' => Database::ADMIN }.freeze
+        ISMASTER_OP_MSG = {
+          isMaster: 1,
+          '$db' => Database::ADMIN,
+        }.freeze
 
         # The constant for the ismaster command.
         #
@@ -54,27 +61,6 @@ module Mongo
         # @since 2.5.0
         ISMASTER_OP_MSG_BYTES = ISMASTER_OP_MSG_MESSAGE.serialize.to_s.freeze
 
-        # The default time in seconds to timeout a connection attempt.
-        #
-        # @since 2.1.2
-        #
-        # @deprecated Please use Server::CONNECT_TIMEOUT instead. Will be removed in 3.0.0
-        CONNECT_TIMEOUT = 10.freeze
-
-        # Key for compression algorithms in the response from the server during handshake.
-        #
-        # @since 2.5.0
-        # @deprecated
-        COMPRESSION = 'compression'.freeze
-
-        # Warning message that the server has no compression algorithms in common with those requested
-        #   by the client.
-        #
-        # @since 2.5.0
-        # @deprecated
-        COMPRESSION_WARNING = 'The server has no compression algorithms in common with those requested. ' +
-                                'Compression will not be used.'.freeze
-
         # Creates a new connection object to the specified target address
         # with the specified options.
         #
@@ -84,14 +70,6 @@ module Mongo
         #
         # @note Monitoring connections do not authenticate.
         #
-        # @api private
-        #
-        # @example Create the connection.
-        #   Connection.new(address)
-        #
-        # @note Connection must never be directly instantiated outside of a
-        #   Monitor.
-        #
         # @param [ Mongo::Address ] address The address the connection is for.
         # @param [ Hash ] options The connection options.
         #
@@ -114,7 +92,7 @@ module Mongo
         # @since 2.0.0
         def initialize(address, options = {})
           @address = address
-          @options = options.freeze
+          @options = options.dup.freeze
           @app_metadata = options[:app_metadata]
           @socket = nil
           @pid = Process.pid
@@ -127,19 +105,70 @@ module Mongo
         # @return [ Mongo::Address ] address The address to connect to.
         attr_reader :address
 
-        # Send the preserialized ismaster call.
+        # Returns the monitoring socket timeout.
         #
-        # @example Send a preserialized ismaster message.
-        #   connection.ismaster
+        # Note that monitoring connections use the connect timeout value as
+        # the socket timeout value. See the Server Discovery and Monitoring
+        # specification for details.
         #
-        # @return [ BSON::Document ] The ismaster result.
+        # @return [ Float ] The socket timeout in seconds.
         #
-        # @since 2.2.0
-        def ismaster
-          ensure_connected do |socket|
-            read_with_one_retry(retry_message: retry_message) do
-              socket.write(ISMASTER_BYTES)
-              Protocol::Message.deserialize(socket).documents[0]
+        # @since 2.4.3
+        def socket_timeout
+          options[:connect_timeout] || Server::CONNECT_TIMEOUT
+        end
+
+        attr_reader :server_connection_id
+
+        # Sends a message and returns the result.
+        #
+        # @param [ Protocol::Message ] The message to send.
+        #
+        # @return [ Protocol::Message ] The result.
+        def dispatch(message)
+          dispatch_bytes(message.serialize.to_s)
+        end
+
+        # Sends a preserialized message and returns the result.
+        #
+        # @param [ String ] The serialized message to send.
+        #
+        # @option opts [ Numeric ] :read_socket_timeout The timeout to use for
+        #   each read operation.
+        #
+        # @return [ Protocol::Message ] The result.
+        def dispatch_bytes(bytes, **opts)
+          write_bytes(bytes)
+          read_response(
+            socket_timeout: opts[:read_socket_timeout],
+          )
+        end
+
+        def write_bytes(bytes)
+          unless connected?
+            raise ArgumentError, "Trying to dispatch on an unconnected connection #{self}"
+          end
+
+          add_server_connection_id do
+            add_server_diagnostics do
+              socket.write(bytes)
+            end
+          end
+        end
+
+        # @option opts [ Numeric ] :socket_timeout The timeout to use for
+        #   each read operation.
+        def read_response(**opts)
+          unless connected?
+            raise ArgumentError, "Trying to read on an unconnected connection #{self}"
+          end
+
+          add_server_connection_id do
+            add_server_diagnostics do
+              Protocol::Message.deserialize(socket,
+                Protocol::Message::MAX_MESSAGE_SIZE,
+                nil,
+                **opts)
             end
           end
         end
@@ -158,10 +187,13 @@ module Mongo
         #
         # @since 2.0.0
         def connect!
-          unless @socket
-            socket = address.socket(socket_timeout, ssl_options, address.options)
-            handshake!(socket)
-            @socket = socket
+          if @socket
+            raise ArgumentError, 'Monitoring connection already connected'
+          end
+
+          @socket = add_server_diagnostics do
+            address.socket(socket_timeout, ssl_options.merge(
+              connection_address: address, monitor: true))
           end
           true
         end
@@ -182,46 +214,44 @@ module Mongo
         # @since 2.0.0
         def disconnect!(options = nil)
           if socket
-            socket.close
+            socket.close rescue nil
             @socket = nil
           end
           true
         end
 
-        # Get the socket timeout.
-        #
-        # @example Get the socket timeout.
-        #   connection.socket_timeout
-        #
-        # @return [ Float ] The socket timeout in seconds. Note that the Monitor's connection
-        #  uses the connect timeout value for calling ismaster. See the Server Discovery and
-        #  Monitoring specification for details.
-        #
-        # @since 2.4.3
-        def socket_timeout
-          @timeout ||= options[:connect_timeout] || Server::CONNECT_TIMEOUT
-        end
-        # @deprecated Please use :socket_timeout instead. Will be removed in 3.0.0
-        alias :timeout :socket_timeout
-
-        private
-
-        def handshake!(socket)
-          if @app_metadata
-            socket.write(@app_metadata.ismaster_bytes)
-            reply = Protocol::Message.deserialize(socket, Mongo::Protocol::Message::MAX_MESSAGE_SIZE).documents[0]
-            set_compressor!(reply)
-            reply
+        def handshake!
+          payload = if @app_metadata
+            @app_metadata.ismaster_bytes
           else
-            log_warn("Asked to handshake with #{address} but there was no app metadata provided")
+            log_warn("No app metadata provided for handshake with #{address}")
+            ISMASTER_BYTES
           end
-        rescue => e
-          log_warn("Failed to handshake with #{address}: #{e.class}: #{e}:\n#{e.backtrace[0..5].join("\n")}")
+          message = dispatch_bytes(payload)
+          reply = message.documents.first
+          set_compressor!(reply)
+          @server_connection_id = reply['connectionId']
+          reply
+        rescue => exc
+          msg = "Failed to handshake with #{address}"
+          Utils.warn_monitor_exception(msg, exc,
+            logger: options[:logger],
+            log_prefix: options[:log_prefix],
+            bg_error_backtrace: options[:bg_error_backtrace],
+          )
           raise
         end
 
-        def retry_message
-          "Retrying ismaster in monitor for #{address}"
+        private
+
+        def add_server_connection_id
+          yield
+        rescue Mongo::Error => e
+          if server_connection_id
+            note = "sconn:#{server_connection_id}"
+            e.add_note(note)
+          end
+          raise e
         end
       end
     end

data/lib/mongo/server/pending_connection.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2019 MongoDB, Inc.
+# Copyright (C) 2019-2020 MongoDB Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -21,9 +21,8 @@ module Mongo
     class PendingConnection < ConnectionBase
       extend Forwardable
 
-      def initialize(socket, description, server, monitoring, options = {})
+      def initialize(socket, server, monitoring, options = {})
         @socket = socket
-        @description = description
         @options = options
         @server = server
         @monitoring = monitoring
@@ -35,9 +34,222 @@ module Mongo
       #   PendingConnection instance was created.
       attr_reader :id
 
+      def handshake_and_authenticate!
+        speculative_auth_doc = nil
+        if options[:user] || options[:auth_mech]
+          # To create an Auth instance, we need to specify the mechanism,
+          # but at this point we don't know the mechanism that ultimately
+          # will be used (since this depends on the data returned by
+          # the handshake, specifically server version).
+          # However, we know that only 4.4+ servers support speculative
+          # authentication, and those servers also generally support
+          # SCRAM-SHA-256. We expect that user accounts created for 4.4+
+          # servers would generally allow SCRAM-SHA-256 authentication;
+          # user accounts migrated from pre-4.4 servers may only allow
+          # SCRAM-SHA-1. The use of SCRAM-SHA-256 by default is thus
+          # sensible, and it is also mandated by the speculative auth spec.
+          # If no mechanism was specified and we are talking to a 3.0+
+          # server, we'll send speculative auth document, the server will
+          # ignore it and we'll perform authentication using explicit
+          # command after having defaulted the mechanism later to CR.
+          # If no mechanism was specified and we are talking to a 4.4+
+          # server and the user account doesn't allow SCRAM-SHA-256, we will
+          # authenticate in a separate command with SCRAM-SHA-1 after
+          # going through SCRAM mechanism negotiation.
+          default_options = Options::Redacted.new(:auth_mech => :scram256)
+          speculative_auth_user = Auth::User.new(default_options.merge(options))
+          speculative_auth = Auth.get(speculative_auth_user, self)
+          speculative_auth_doc = speculative_auth.conversation.speculative_auth_document
+        end
+
+        result = handshake!(speculative_auth_doc: speculative_auth_doc)
+        if speculative_auth_doc && (speculative_auth_result = result['speculativeAuthenticate'])
+          unless description.features.scram_sha_1_enabled?
+            raise Error::InvalidServerAuthResponse, "Speculative auth succeeded on a pre-3.0 server"
+          end
+          case speculative_auth_user.mechanism
+          when :mongodb_x509
+            # Done
+          # We default auth mechanism to scram256, but if user specified
+          # scram explicitly we may be able to authenticate speculatively
+          # with scram.
+          when :scram, :scram256
+            authenticate!(
+              speculative_auth_client_nonce: speculative_auth.conversation.client_nonce,
+              speculative_auth_mech: speculative_auth_user.mechanism,
+              speculative_auth_result: speculative_auth_result,
+            )
+          else
+            raise NotImplementedError, "Speculative auth unexpectedly succeeded for mechanism #{speculative_auth_user.mechanism.inspect}"
+          end
+        elsif !description.arbiter?
+          authenticate!
+        end
+      end
+
+      private
+
+      # @param [ BSON::Document | nil ] speculative_auth_doc The document to
+      #   provide in speculativeAuthenticate field of ismaster command.
+      #
+      # @return [ BSON::Document ] The document of the ismaster response for
+      #   this particular connection.
+      def handshake!(speculative_auth_doc: nil)
+        unless socket
+          raise Error::HandshakeError, "Cannot handshake because there is no usable socket (for #{address})"
+        end
+
+        ismaster_doc = app_metadata.validated_document
+        if speculative_auth_doc
+          ismaster_doc = ismaster_doc.merge(speculativeAuthenticate: speculative_auth_doc)
+        end
+
+        ismaster_command = Protocol::Query.new(Database::ADMIN, Database::COMMAND,
+          ismaster_doc, :limit => -1)
+
+        response = nil
+        @server.handle_handshake_failure! do
+          begin
+            response = @server.round_trip_time_averager.measure do
+              add_server_diagnostics do
+                socket.write(ismaster_command.serialize.to_s)
+                Protocol::Message.deserialize(socket, Protocol::Message::MAX_MESSAGE_SIZE).documents.first
+              end
+            end
+          rescue => exc
+            msg = "Failed to handshake with #{address}"
+            Utils.warn_monitor_exception(msg, exc,
+              logger: options[:logger],
+              log_prefix: options[:log_prefix],
+              bg_error_backtrace: options[:bg_error_backtrace],
+            )
+            raise
+          end
+        end
+
+        post_handshake(response, @server.round_trip_time_averager.average_round_trip_time)
+
+        response
+      end
+
+      # @param [ String | nil ] speculative_auth_client_nonce The client
+      #   nonce used in speculative auth on this connection that
+      #   produced the specified speculative auth result.
+      # @param [ Symbol | nil ] speculative_auth_mech Auth mechanism used
+      #   for speculative auth, if speculative auth succeeded. If speculative
+      #   auth was not performed or it failed, this must be nil.
+      # @param [ BSON::Document | nil ] speculative_auth_result The
+      #   value of speculativeAuthenticate field of ismaster response of
+      #   the handshake on this connection.
+      def authenticate!(
+        speculative_auth_client_nonce: nil,
+        speculative_auth_mech: nil,
+        speculative_auth_result: nil
+      )
+        if options[:user] || options[:auth_mech]
+          @server.handle_auth_failure! do
+            begin
+              auth = Auth.get(
+                resolved_user(speculative_auth_mech: speculative_auth_mech),
+                self,
+                speculative_auth_client_nonce: speculative_auth_client_nonce,
+                speculative_auth_result: speculative_auth_result,
+              )
+              auth.login
+            rescue => exc
+              msg = "Failed to authenticate to #{address}"
+              Utils.warn_monitor_exception(msg, exc,
+                logger: options[:logger],
+                log_prefix: options[:log_prefix],
+                bg_error_backtrace: options[:bg_error_backtrace],
+              )
+              raise
+            end
+          end
+        end
+      end
+
       def ensure_connected
         yield @socket
       end
+
+      # This is a separate method to keep the nesting level down.
+      #
+      # @return [ Server::Description ] The server description calculated from
+      #   ismaster response for this particular connection.
+      def post_handshake(response, average_rtt)
+        if response["ok"] == 1
+          # Auth mechanism is entirely dependent on the contents of
+          # ismaster response *for this connection*.
+          # Ismaster received by the monitoring connection should advertise
+          # the same wire protocol, but if it doesn't, we use whatever
+          # the monitoring connection advertised for filling out the
+          # server description and whatever the non-monitoring connection
+          # (that's this one) advertised for performing auth on that
+          # connection.
+          @sasl_supported_mechanisms = response['saslSupportedMechs']
+          set_compressor!(response)
+        else
+          @sasl_supported_mechanisms = nil
+        end
+
+        @description = Description.new(address, response, average_rtt).tap do |new_description|
+          @server.cluster.run_sdam_flow(@server.description, new_description)
+        end
+      end
+
+      # The user as going to be used for authentication. This user has the
+      # auth mechanism set and, if necessary, auth source.
+      #
+      # @param [ Symbol | nil ] speculative_auth_mech Auth mechanism used
+      #   for speculative auth, if speculative auth succeeded. If speculative
+      #   auth was not performed or it failed, this must be nil.
+      #
+      # @return [ Auth::User ] The resolved user.
+      def resolved_user(speculative_auth_mech: nil)
+        @resolved_user ||= begin
+          unless options[:user] || options[:auth_mech]
+            raise Mongo::Error, 'No authentication information specified in the client'
+          end
+
+          user_options = Options::Redacted.new(
+            # When speculative auth is performed, we always use SCRAM-SHA-256.
+            # At the same time we perform SCRAM mechanism negotiation in the
+            # ismaster request.
+            # If the credentials we are trying to authenticate with do not
+            # map to an existing user, SCRAM mechanism negotiation will not
+            # return anything which would cause the driver to use
+            # SCRAM-SHA-1. However, on 4.4+ servers speculative auth would
+            # succeed (technically just the first round-trip, not the entire
+            # authentication flow) and we would be continuing it here;
+            # in this case, we must use SCRAM-SHA-256 as the mechanism since
+            # that is what the conversation was started with, even though
+            # SCRAM mechanism negotiation did not return SCRAM-SHA-256 as a
+            # valid mechanism to use for these credentials.
+            :auth_mech => speculative_auth_mech || default_mechanism,
+          ).merge(options)
+          if user_options[:auth_mech] == :mongodb_x509
+            user_options[:auth_source] = '$external'
+          end
+          Auth::User.new(user_options)
+        end
+      end
+
+      def default_mechanism
+        if description.nil?
+          raise Mongo::Error, 'Trying to query default mechanism when handshake has not completed'
+        end
+
+        if description.features.scram_sha_1_enabled?
+          if @sasl_supported_mechanisms&.include?('SCRAM-SHA-256')
+            :scram256
+          else
+            :scram
+          end
+        else
+          :mongodb_cr
+        end
+      end
     end
   end
 end